@dorely13/ai-imagegen-cli 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { mkdir as mkdir5, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile4, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { basename, dirname as dirname5, extname, join as join5, resolve as resolve3 } from "node:path";
 
 // ../../packages/core/dist/types.js
@@ -85,7 +85,9 @@ function normalizeOutputFormat(value) {
     return "jpeg";
   if (normalized === "webp")
     return "webp";
-  return "png";
+  if (normalized === "png" || normalized === "")
+    return "png";
+  throw new ProviderError({ kind: "usage", message: "Output format must be png, jpeg, or webp." });
 }
 
 // ../../packages/core/dist/image-size.js
@@ -230,7 +232,7 @@ var IMAGES_ENDPOINT = "https://chatgpt.com/backend-api/codex/images";
 var DEFAULT_REDIRECT_URI = "http://localhost:1455/auth/callback";
 var LOOPBACK_PORT = 1455;
 var CALLBACK_PATH = "/auth/callback";
-var DEFAULT_IMAGE_MODEL = "gpt-image-2.5-flare";
+var DEFAULT_IMAGE_MODEL = "gpt-image-2.6-flare";
 var DEFAULT_QUALITY = "auto";
 var REQUEST_TIMEOUT_SECONDS = 600;
 var MAX_REFERENCE_IMAGES2 = 4;
@@ -526,9 +528,9 @@ var FileCredentialStore = class {
     return { backend: "file", location: this.filePath };
   }
   async readAll() {
-    const { readFile: readFile4 } = await import("node:fs/promises");
+    const { readFile: readFile5 } = await import("node:fs/promises");
     try {
-      const raw = await readFile4(this.filePath, "utf8");
+      const raw = await readFile5(this.filePath, "utf8");
       let value;
       try {
         value = JSON.parse(raw);
@@ -807,6 +809,36 @@ function buildBody(args) {
     body["images"] = args.images.map((image) => ({ image_url: toDataUrl(image) }));
   return body;
 }
+var MASK_INSTRUCTION = "The last image is an edit mask, not content to reproduce. Apply the requested change only where the mask is transparent. Keep every area where the mask is opaque exactly as it is in the first image.";
+async function normalizeMask(mask, source) {
+  const usage2 = (message) => new ProviderError({ kind: "usage", message });
+  let pixels;
+  let width;
+  let height;
+  let sourceWidth;
+  let sourceHeight;
+  try {
+    const decoded = await sharp(mask.data).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    ({ width, height } = decoded.info);
+    pixels = decoded.data;
+    ({ width: sourceWidth, height: sourceHeight } = await sharp(source.data).metadata());
+  } catch {
+    throw usage2("Mask and source must be readable PNG, JPEG, or WebP images.");
+  }
+  if (width !== sourceWidth || height !== sourceHeight) {
+    throw usage2(`Mask is ${width}x${height} but the source is ${sourceWidth}x${sourceHeight}; they must match.`);
+  }
+  let editable = false;
+  for (let i = 0; i < pixels.length; i += 4) {
+    const edit = pixels[i + 3] < 128;
+    editable ||= edit;
+    pixels.fill(edit ? 0 : 255, i, i + 4);
+  }
+  if (!editable)
+    throw usage2("Mask has no transparent pixels; make the area to edit transparent.");
+  const data = await sharp(pixels, { raw: { width, height, channels: 4 } }).png().toBuffer();
+  return { data, contentType: "image/png" };
+}
 var CodexImageProvider = class {
   tokens;
   name = PROVIDER_NAME;
@@ -825,7 +857,16 @@ var CodexImageProvider = class {
     return this.runAll(request, references.length > 0 ? "edits" : "generations", references);
   }
   async edit(request) {
-    return this.runAll(request, "edits", [request.sourceImage, ...request.referenceImages ?? []].slice(0, MAX_REFERENCE_IMAGES2));
+    const images = [request.sourceImage, ...request.referenceImages ?? []];
+    if (!request.mask)
+      return this.runAll(request, "edits", images.slice(0, MAX_REFERENCE_IMAGES2));
+    if (images.length + 1 > MAX_REFERENCE_IMAGES2) {
+      throw new ProviderError({ kind: "usage", message: `Codex accepts at most ${MAX_REFERENCE_IMAGES2} edit images; a mask uses one, leaving room for ${MAX_REFERENCE_IMAGES2 - 2} --reference images.` });
+    }
+    const mask = await normalizeMask(request.mask, request.sourceImage);
+    return this.runAll(request, "edits", [...images, mask], `${request.prompt}
+
+${MASK_INSTRUCTION}`);
   }
   resolveImageModel(request) {
     const model = (request.model ?? this.imageModel).trim();
@@ -837,16 +878,16 @@ var CodexImageProvider = class {
     }
     return model;
   }
-  async runAll(request, endpoint, images) {
+  async runAll(request, endpoint, images, modelPrompt = request.prompt) {
     const format = normalizeOutputFormat(request.format);
     const size = this.sizePolicy.resolveSize(request.size);
-    const imageModel2 = this.resolveImageModel(request);
-    const body = JSON.stringify(buildBody({ prompt: request.prompt, model: imageModel2, size, quality: request.quality ?? DEFAULT_QUALITY, images }));
+    const requestedModel = this.resolveImageModel(request);
+    const body = JSON.stringify(buildBody({ prompt: modelPrompt, model: requestedModel, size, quality: request.quality ?? DEFAULT_QUALITY, images }));
     const results = [];
     for (let i = 0, count = normalizeCount(request.count); i < count; i += 1) {
       results.push(await this.sendOnce(endpoint, body, format, request.prompt));
     }
-    return { provider: this.name, imageModel: imageModel2, images: results };
+    return { provider: this.name, requestedModel, images: results };
   }
   async sendOnce(endpoint, body, format, prompt) {
     let accessToken = await this.tokens.getValidAccessToken();
@@ -897,6 +938,8 @@ var CodexImageProvider = class {
       height,
       prompt,
       responseId: typeof item["generation_id"] === "string" ? item["generation_id"] : void 0,
+      // The endpoint accepts any requested model and currently names none in its response.
+      servedModel: typeof payload["model"] === "string" ? payload["model"] : void 0,
       usage: {
         requestId,
         imageGeneration: payload["usage"],
@@ -1113,8 +1156,6 @@ var GeminiImageProvider = class {
     const count = request.count ?? 1;
     if (!Number.isInteger(count) || count < 1 || count > 4)
       throw error("usage", "Image count must be from 1 to 4.");
-    if (request.format && !["png", "jpeg", "jpg", "webp"].includes(request.format.trim().toLowerCase()))
-      throw error("usage", "Output format must be png, jpeg, or webp.");
     const format = normalizeOutputFormat(request.format);
     const size = resolveGeminiSize(request.size, model);
     const payload = {
@@ -1149,7 +1190,7 @@ var GeminiImageProvider = class {
     const images = [];
     for (let i = 0; i < count; i++)
       images.push(await this.send(payload, key, format, request.prompt));
-    return { provider: this.name, imageModel: model, images };
+    return { provider: this.name, requestedModel: model, images };
   }
   async send(payload, key, format, prompt) {
     const controller = new AbortController();
@@ -1261,8 +1302,9 @@ function createGeminiEntry() {
 
 // ../../packages/providers-configurable/dist/profiles.js
 import { readFile, mkdir as mkdir2, writeFile, rename, rm as rm2 } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
+var COMFY_FIELDS = ["startCommand", "workflow", "editWorkflow"];
 var usage = (message) => new ProviderError({ kind: "usage", message });
 var profileStore = () => resolveCredentialStore();
 function validateApiKey(value) {
@@ -1278,14 +1320,25 @@ function validateProfile(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw usage("Invalid endpoint profile.");
   const p = value;
-  if (Object.keys(p).some((k) => !["name", "api", "baseUrl", "model", "auth"].includes(k)))
-    throw usage("Endpoint profiles accept only name, api, baseUrl, model, and auth; store keys through auth login.");
+  if (Object.keys(p).some((k) => !["name", "api", "baseUrl", "model", "auth", ...COMFY_FIELDS].includes(k)))
+    throw usage("Endpoint profiles accept only name, api, baseUrl, model, auth, startCommand, workflow, and editWorkflow; store keys through auth login.");
   if (typeof p.name !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(p.name) || ["codex", "gemini"].includes(p.name))
     throw usage("Endpoint name must use lowercase letters, digits, and hyphens, and cannot be codex or gemini.");
-  if (p.api !== "openrouter" && p.api !== "openai-images")
-    throw usage("API format must be openrouter or openai-images.");
+  if (p.api !== "openrouter" && p.api !== "openai-images" && p.api !== "comfyui")
+    throw usage("API format must be openrouter, openai-images, or comfyui.");
   if (p.auth !== void 0 && p.auth !== "bearer" && p.auth !== "none")
     throw usage("Auth must be bearer or none.");
+  if (p.api === "comfyui" && p.auth === "bearer")
+    throw usage("ComfyUI profiles do not use API keys. Use --auth none.");
+  if (p.api !== "comfyui" && COMFY_FIELDS.some((k) => p[k] !== void 0))
+    throw usage("--start-command, --workflow, and --edit-workflow apply only to comfyui profiles.");
+  for (const field of COMFY_FIELDS) {
+    const value2 = p[field];
+    if (value2 !== void 0 && (typeof value2 !== "string" || !value2.trim()))
+      throw usage(`${field} must not be blank.`);
+    if (field !== "startCommand" && value2 && !isAbsolute(value2))
+      throw usage(`${field} must be an absolute path.`);
+  }
   const raw = p.baseUrl ?? (p.api === "openrouter" ? "https://openrouter.ai/api/v1" : void 0);
   let url;
   try {
@@ -1300,12 +1353,18 @@ function validateProfile(value) {
     throw usage("Base URL must use HTTPS (or loopback HTTP), without credentials, query, or fragment.");
   if (p.model !== void 0 && (typeof p.model !== "string" || !p.model.trim()))
     throw usage("Default model must not be blank.");
+  if (p.api === "comfyui" && p.model === void 0)
+    throw usage("ComfyUI profiles need --model: flux3-klein, flux3-klein-raw, or your name for the model in --workflow.");
   return {
     name: p.name,
     api: p.api,
     baseUrl: url.toString().replace(/\/+$/, ""),
-    auth: p.auth ?? "bearer",
-    ...typeof p.model === "string" ? { model: p.model.trim() } : {}
+    auth: p.auth ?? (p.api === "comfyui" ? "none" : "bearer"),
+    ...typeof p.model === "string" ? { model: p.model.trim() } : {},
+    ...Object.fromEntries(COMFY_FIELDS.flatMap((field) => {
+      const value2 = p[field];
+      return typeof value2 === "string" ? [[field, value2.trim()]] : [];
+    }))
   };
 }
 var ProfileRepository = class {
@@ -1406,7 +1465,7 @@ async function profileKey(profile, store) {
 }
 
 // ../../packages/providers-configurable/dist/provider.js
-import sharp3 from "sharp";
+import sharp4 from "sharp";
 
 // ../../packages/providers-configurable/dist/image-size.js
 function imageSize(value, api) {
@@ -1426,10 +1485,27 @@ function imageSize(value, api) {
   if (pixels && Number.isSafeInteger(Number(pixels[1])) && Number.isSafeInteger(Number(pixels[2])) && Number(pixels[1]) > 0 && Number(pixels[2]) > 0)
     return { size: `${Number(pixels[1])}x${Number(pixels[2])}` };
   const ratio = /^(\d+(?:\.\d+)?)\s*[:/]\s*(\d+(?:\.\d+)?)$/.exec(size);
-  if (api === "openrouter" && ratio && Number(ratio[1]) > 0 && Number(ratio[2]) > 0 && Number.isFinite(Number(ratio[1]) / Number(ratio[2])))
+  if (api !== "openai-images" && ratio && Number(ratio[1]) > 0 && Number(ratio[2]) > 0 && Number.isFinite(Number(ratio[1]) / Number(ratio[2])))
     return { aspect_ratio: `${Number(ratio[1])}:${Number(ratio[2])}` };
   throw usage(api === "openai-images" ? "This API format requires WIDTHxHEIGHT or a preset; arbitrary aspect-only sizes are unsupported." : "Use WIDTHxHEIGHT, an aspect ratio, preset, or auto.");
 }
+function comfySize(value) {
+  const fields = imageSize(value, "comfyui");
+  let width, height;
+  if (fields.aspect_ratio) {
+    const [w, h] = fields.aspect_ratio.split(":").map(Number);
+    const scale = Math.sqrt(1024 * 1024 / (w * h));
+    [width, height] = [w * scale, h * scale];
+  } else if (fields.size)
+    [width, height] = fields.size.split("x").map(Number);
+  else
+    return void 0;
+  width = Math.round(width / 16) * 16;
+  height = Math.round(height / 16) * 16;
+  if (Math.min(width, height) < 256 || Math.max(width, height) > 2048)
+    throw usage("ComfyUI image edges must be from 256 to 2048 pixels.");
+  return { width, height };
+}
 
 // ../../packages/providers-configurable/dist/http.js
 var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -1560,6 +1636,625 @@ function openAIRequest(model, request, images, mask) {
   return { path: "images/edits", body, json: false };
 }
 
+// ../../packages/providers-configurable/dist/comfyui.js
+import { randomInt, randomUUID as randomUUID2 } from "node:crypto";
+import sharp3 from "sharp";
+
+// ../../packages/providers-configurable/dist/comfyui-workflow.js
+import { readFile as readFile2 } from "node:fs/promises";
+var TOKEN = /\{\{(\w+)\}\}/g;
+function usedTokens(graph) {
+  const used = /* @__PURE__ */ new Set();
+  for (const node of Object.values(graph))
+    for (const value of Object.values(node.inputs))
+      if (typeof value === "string")
+        for (const match of value.matchAll(TOKEN))
+          used.add(match[1]);
+  return used;
+}
+async function loadWorkflow(path) {
+  const invalid = (detail) => new ProviderError({
+    kind: "configuration",
+    message: `ComfyUI workflow ${path} ${detail}`
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile2(path, "utf8"));
+  } catch {
+    throw invalid("could not be read as JSON.");
+  }
+  const nodes = Object.values(record2(parsed));
+  if (!nodes.length || nodes.some((node) => typeof record2(node).class_type !== "string" || typeof record2(node).inputs !== "object"))
+    throw invalid("is not in API format. Export it from ComfyUI as API JSON.");
+  const graph = parsed;
+  const used = usedTokens(graph);
+  const unknown = [...used].filter((t) => !/^(prompt|seed|width|height|image[1-9]\d*)$/.test(t));
+  if (unknown.length)
+    throw invalid(`uses unknown tokens: ${unknown.join(", ")}.`);
+  if (!used.has("prompt") || !used.has("seed"))
+    throw invalid("must use {{prompt}} and {{seed}}.");
+  if (used.has("width") !== used.has("height"))
+    throw invalid("must use {{width}} and {{height}} together.");
+  const images = [...used].filter((t) => t.startsWith("image")).length;
+  for (let i = 1; i <= images; i++)
+    if (!used.has(`image${i}`))
+      throw invalid(`must number its image tokens from {{image1}} in order.`);
+  return { graph, images, sized: used.has("width") };
+}
+function fillWorkflow({ graph }, { prompt, seed, size, images }) {
+  const values = {
+    prompt,
+    seed,
+    ...size ?? {},
+    ...Object.fromEntries(images.map((image, i) => [`image${i + 1}`, image]))
+  };
+  const fill = (value) => {
+    if (typeof value !== "string")
+      return value;
+    const whole = /^\{\{(\w+)\}\}$/.exec(value);
+    if (whole)
+      return values[whole[1]];
+    return value.replace(TOKEN, (_, token) => String(values[token]));
+  };
+  return Object.fromEntries(Object.entries(graph).map(([id, node]) => [
+    id,
+    {
+      ...node,
+      inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, value]) => [key, fill(value)]))
+    }
+  ]));
+}
+
+// ../../packages/providers-configurable/dist/validation.js
+function validateImageRequest(request, images) {
+  if ((request.referenceImages?.length ?? 0) > 4)
+    throw usage("At most four reference images are allowed.");
+  const count = request.count ?? 1;
+  if (!Number.isInteger(count) || count < 1 || count > 4)
+    throw usage("Image count must be from 1 to 4.");
+  for (const image of images)
+    if (!["image/png", "image/jpeg", "image/webp"].includes(image.contentType))
+      throw usage("Input images must be PNG, JPEG, or WebP.");
+  const format = (request.format ?? "png").trim().toLowerCase().replace(/^jpg$/, "jpeg");
+  if (!["png", "jpeg", "webp"].includes(format))
+    throw usage("Output format must be png, jpeg, or webp.");
+  return { count, format };
+}
+
+// ../../packages/providers-configurable/dist/flux3-klein-prompts.js
+var FLUX3_KLEIN_GENERATE_PROMPT = `You are the prompt upsampler of a text-to-image model. Expand the user's short request into ONE detailed, self-contained caption: the exact text the image model receives. Output only the caption, with no greetings, explanations, refusals, questions, Markdown, headings, JSON, coordinates, ids or angle-bracket tokens, and no quotes around it. If the input is not clearly an image request, caption a visualization of its concept. The request may begin with a "TARGET CANVAS: W:H" line: compose for that canvas (wide spreads content sideways, tall stacks it) and never mention the ratio or the canvas.
+
+Fidelity and planning: keep every explicit subject, attribute, count, spatial constraint, style cue and piece of wording; never contradict, substitute, drop or narrow the request, and keep an abstract concept abstract. Decide everything left open as ONE concrete, consistent plan; never offer alternatives or hedge. Never re-express a stated constraint through another mechanism; add camera optics (depth of field, bokeh, blur) only when asked for or implied. Without a stated style, plan an actual photograph and open with the medium convention ("Full-color outdoor photograph, ...", "Full-color indoor photograph, ...", "Studio photograph, ...", "Close-up photograph, ..."); keep "Photorealistic" for renders, and turn "photorealistic" or "realistic" requests for photos into the photograph convention. Give a photograph a few ordinary, non-ideal specifics drawn from the scene's own objects instead of the stock-photo ideal. Do not invent names, brands, logos or celebrities; keep user-named ones. A long request keeps its content but not its wording: drop appraisal and sales vocabulary, turn moods into observable physical facts, and add only new concrete content with positions. Time of day is lighting, not rendered text.
+
+Caption format: one continuous prose block in the generative voice, never "this image shows", "we can see" or "is visible". Lead with medium and style, then scene, lighting and camera, then the subjects with concrete colors, materials and state. Every person in focus gets an observable profile: ethnicity, gender, age range, skin tone ("fair skin", "brown skin"), hair and clothing. Make the layout reconstructable from words: frame-relative positions (frame-left, frame-right, upper, lower, foreground, midground, background), sentence-initial anchors ("On the left, ...", "In the background, ..."), relations (holds, faces, behind) and a consistent order; describe up to about ten instances one by one, beyond that give the exact count and arrangement. Out-of-focus or distant planes are shapes, colors and silhouettes, never identities or readable text, and the background takes about a sixth of the caption. Be definite: no hedging adverbs, no quality or emotion judgments, no closing sentence about mood; state negations as what is present. Rendered text: transcribe every wording verbatim inside double quotes in its original language and script, keep the line breaks of multi-line text, and give its typography, color and placement; author concrete, domain-correct wording when the request needs text it does not supply, and name canonical structures (calendar, keyboard, periodic table) exactly with their full layout. All prose is English; only quoted text keeps its language. Typical length is 100 to 350 words, more for complex scenes.
+
+Output only the caption.`;
+var FLUX3_KLEIN_EDIT_PROMPT = `You are the prompt upsampler of an image-editing model. You see the reference image(s), attached in order (the first image, the second image, ...), and the user's short request. Expand it into ONE detailed, self-contained instruction: the caption the editing model receives together with the same images. Output only the instruction as one continuous English prose block, with no greetings, explanations, Markdown, JSON, coordinates, ids or angle-bracket tokens. Read a vague or conversational request as the most plausible edit of the supplied images.
+
+Pick the voice by task shape. When one reference stays and gets bounded changes, write an imperative editing instruction on it ("Remove the ...", "Change the ... to ...", "Zoom in on ..."); a whole-image transformation opens with its scope ("Convert the entire image into ...", "Apply a ... filter over the entire scene", "Horizontally flip the entire image so that ...", "Shift the camera viewpoint to ...", then where the major elements should now be). When the references are drawn into a newly composed frame (combining subjects, a new scene, a garment, object or style donor), write a generation request ("Create a photograph of ...", "Create an anime-style illustration of ...", "Generate a new image featuring ...") that says what to take from each image, by ordinal, and what is newly generated.
+
+Keep every explicit edit, constraint, count, position, style cue and piece of wording, and decide what is left open as one concrete plan. Ground everything in what is actually visible: identify each referent unambiguously by its real appearance, never mention content that is not there, and use every image the user attached. State every end state concretely (which color, how large, which pose, which material) and give new content enough appearance to be generated. Cover the knock-on effects of the change (shadows, reflections, occlusion, perspective, scale, lighting) and say what fills a removed region. A zoom-in names what stays in frame and which neighbors are cropped out; an outpainting continues the scene in the same medium. Describe the change, not the whole scene, and close an editing instruction with one compact clause naming what stays unchanged; transferred people keep their identity, face and accessories unless asked otherwise. Transcribe on-image text verbatim in its original language inside double quotes, with line breaks as \\n, and match the original font, size and color when replacing it. Name recognizable public figures, brands and landmarks you can see. Directions are frame-relative; use no evaluative or quality words. Typical length is 50 to 150 words.
+
+Output only the instruction.`;
+
+// ../../packages/providers-configurable/dist/flux3-klein.js
+var FLUX3_KLEIN_CHECKPOINT = "flux3-image-klein-int8-convrot";
+var FLUX3_KLEIN_MODELS = [
+  {
+    id: "flux3-klein",
+    name: "FLUX 3 Klein, prompt expanded by its upsampler",
+    upsample: true
+  },
+  {
+    id: "flux3-klein-raw",
+    name: "FLUX 3 Klein, prompt used verbatim as the full caption",
+    upsample: false
+  }
+];
+var UPSAMPLER = "qwen3.5_9b_flux3_prompt_upsampler_w4a8.safetensors";
+var ENCODER = "qwen3vl_4b_int8_convrot.safetensors";
+var VAE = "flux2-vae.safetensors";
+var WEIGHTS = [
+  {
+    node: "UNETLoader",
+    input: "unet_name",
+    folder: "diffusion_models",
+    file: `${FLUX3_KLEIN_CHECKPOINT}.safetensors`
+  },
+  {
+    node: "CLIPLoader",
+    input: "clip_name",
+    folder: "text_encoders",
+    file: ENCODER
+  },
+  {
+    node: "VAELoader",
+    input: "vae_name",
+    folder: "vae",
+    file: VAE
+  }
+];
+var flux3KleinWeights = (model) => model.upsample ? [
+  ...WEIGHTS,
+  {
+    node: "CLIPLoader",
+    input: "clip_name",
+    folder: "text_encoders",
+    file: UPSAMPLER
+  }
+] : WEIGHTS;
+function flux3KleinModel(id) {
+  const model = FLUX3_KLEIN_MODELS.find((m) => m.id === id);
+  if (!model)
+    throw usage(`Built-in ComfyUI models are ${FLUX3_KLEIN_MODELS.map((m) => m.id).join(" and ")}. Add --workflow to the profile for any other model.`);
+  return model;
+}
+var STEPS = { low: 4, medium: 8, high: 16, auto: 16 };
+function flux3KleinSteps(quality) {
+  const steps = STEPS[(quality ?? "auto").trim().toLowerCase()];
+  if (!steps)
+    throw usage("Quality must be low, medium, high, or auto.");
+  return steps;
+}
+function upsamplerRequest(job) {
+  if (job.images.length || !job.size || job.size.width === job.size.height)
+    return job.prompt;
+  const divisor = (a, b) => b ? divisor(b, a % b) : a;
+  const shared = divisor(job.size.width, job.size.height);
+  return `TARGET CANVAS: ${job.size.width / shared}:${job.size.height / shared}
+${job.prompt}`;
+}
+function flux3KleinWorkflow(job) {
+  const editing = job.images.length > 0;
+  const nodes = {
+    model: {
+      class_type: "UNETLoader",
+      inputs: {
+        unet_name: `${FLUX3_KLEIN_CHECKPOINT}.safetensors`,
+        weight_dtype: "default"
+      }
+    },
+    encoder: {
+      class_type: "CLIPLoader",
+      inputs: { clip_name: ENCODER, type: "flux3", device: "default" }
+    },
+    vae: { class_type: "VAELoader", inputs: { vae_name: VAE } }
+  };
+  job.images.forEach((image, i) => {
+    nodes[`image${i}`] = { class_type: "LoadImage", inputs: { image } };
+  });
+  if (job.upsample) {
+    nodes.upsampler_clip = {
+      class_type: "CLIPLoader",
+      inputs: { clip_name: UPSAMPLER, type: "flux3", device: "default" }
+    };
+    nodes.upsampler = {
+      class_type: "TextGenerateV2",
+      inputs: {
+        clip: ["upsampler_clip", 0],
+        prompt: upsamplerRequest(job),
+        system_prompt: editing ? FLUX3_KLEIN_EDIT_PROMPT : FLUX3_KLEIN_GENERATE_PROMPT,
+        max_length: 3584,
+        sampling_mode: "on",
+        "sampling_mode.temperature": 1,
+        "sampling_mode.top_k": 1,
+        "sampling_mode.top_p": 0.95,
+        "sampling_mode.min_p": 0,
+        "sampling_mode.repetition_penalty": 1.05,
+        "sampling_mode.presence_penalty": editing ? 0 : 1.5,
+        "sampling_mode.seed": 0,
+        thinking: false,
+        use_default_template: true,
+        mtp: "off",
+        ...Object.fromEntries(job.images.map((_, i) => [`images.image${i + 1}`, [`image${i}`, 0]]))
+      }
+    };
+    nodes.caption = {
+      class_type: "PreviewAny",
+      inputs: { source: ["upsampler", 0] }
+    };
+  }
+  nodes.positive = {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      clip: ["encoder", 0],
+      text: job.upsample ? ["upsampler", 0] : job.prompt
+    }
+  };
+  nodes.negative = editing ? {
+    class_type: "ConditioningZeroOut",
+    inputs: { conditioning: ["positive", 0] }
+  } : {
+    class_type: "CLIPTextEncode",
+    inputs: { clip: ["encoder", 0], text: "" }
+  };
+  if (editing)
+    nodes.references = {
+      class_type: "ReferenceMultiLatent",
+      inputs: {
+        positive: ["positive", 0],
+        negative: ["negative", 0],
+        vae: ["vae", 0],
+        resolution: "resize",
+        "resolution.megapixels": 1,
+        ...Object.fromEntries(job.images.map((_, i) => [`images.image${i}`, [`image${i}`, 0]]))
+      }
+    };
+  if (!editing || job.size) {
+    const { width, height } = job.size ?? { width: 1024, height: 1024 };
+    nodes.latent = {
+      class_type: "EmptyFlux2LatentImage",
+      inputs: { width, height, batch_size: 1 }
+    };
+  }
+  nodes.sampler = {
+    class_type: "KSampler",
+    inputs: {
+      model: ["model", 0],
+      seed: job.seed,
+      steps: job.steps,
+      cfg: 1,
+      sampler_name: "euler",
+      scheduler: "simple",
+      denoise: 1,
+      positive: editing ? ["references", 0] : ["positive", 0],
+      negative: editing ? ["references", 1] : ["negative", 0],
+      // Without a requested size, edits keep the first reference's shape.
+      latent_image: nodes.latent ? ["latent", 0] : ["references", 2]
+    }
+  };
+  nodes.decode = {
+    class_type: "VAEDecode",
+    inputs: { samples: ["sampler", 0], vae: ["vae", 0] }
+  };
+  nodes.output = {
+    class_type: "PreviewImage",
+    inputs: { images: ["decode", 0] }
+  };
+  return nodes;
+}
+
+// ../../packages/providers-configurable/dist/comfyui.js
+var EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp"
+};
+function comboOptions(spec) {
+  if (!Array.isArray(spec))
+    return void 0;
+  const choices = spec[0] === "COMBO" ? record2(spec[1]).options : spec[0];
+  return Array.isArray(choices) ? choices : void 0;
+}
+var comboChoices = (spec) => comboOptions(spec) ?? [];
+async function sourceShape(image) {
+  try {
+    const { width, height } = await sharp3(image.data).metadata();
+    return comfySize(`${width}:${height}`);
+  } catch (e) {
+    if (e instanceof ProviderError)
+      throw e;
+    throw usage("Could not read the source image's dimensions.");
+  }
+}
+function executionFailure(messages) {
+  const failure2 = Array.isArray(messages) ? messages.find((m) => Array.isArray(m) && m[0] === "execution_error") : void 0;
+  const detail = record2(Array.isArray(failure2) ? failure2[1] : void 0);
+  const node = typeof detail.node_type === "string" ? detail.node_type : "the workflow";
+  const reason = typeof detail.exception_message === "string" ? detail.exception_message.replace(/\s+/g, " ").trim().slice(0, 300) : "";
+  const memory = /out ?of ?memory/i.test(`${detail.exception_type} ${reason}`);
+  return new ProviderError({
+    kind: "server",
+    message: `ComfyUI failed in ${node}${reason ? `: ${reason}` : "."}${memory ? " Close other GPU applications or request a smaller --size." : ""}`
+  });
+}
+async function encoded(data, format) {
+  try {
+    const result = await sharp3(data).toFormat(format).toBuffer({ resolveWithObject: true });
+    return {
+      data: result.data,
+      width: result.info.width,
+      height: result.info.height
+    };
+  } catch {
+    throw new ProviderError({
+      kind: "malformed",
+      message: "ComfyUI returned an invalid raster image."
+    });
+  }
+}
+var ComfyUIImageProvider = class {
+  name;
+  profile;
+  baseUrl;
+  defaultModel;
+  http;
+  pollIntervalMs;
+  constructor(profile, options = {}) {
+    const valid = validateProfile(profile);
+    this.profile = valid;
+    this.name = valid.name;
+    this.baseUrl = valid.baseUrl;
+    this.defaultModel = valid.model;
+    this.http = new EndpointHttp(options.fetchImpl, options.timeoutSeconds ?? 600);
+    this.pollIntervalMs = options.pollIntervalMs ?? 500;
+  }
+  sizePolicy = {
+    resolveSize: (size) => {
+      const resolved = comfySize(size);
+      if (!resolved)
+        return { size: "auto" };
+      const { width, height } = resolved;
+      return {
+        width,
+        height,
+        pixels: width * height,
+        size: `${width}x${height}`
+      };
+    }
+  };
+  generate(request) {
+    return this.run(request, request.referenceImages ?? []);
+  }
+  async edit(request) {
+    if (request.mask)
+      throw usage("ComfyUI profiles have no mask input. Describe the edit region in the prompt.");
+    return this.run(request, [
+      request.sourceImage,
+      ...request.referenceImages ?? []
+    ]);
+  }
+  get usesWorkflowFiles() {
+    return Boolean(this.profile.workflow || this.profile.editWorkflow);
+  }
+  async models() {
+    if (this.usesWorkflowFiles) {
+      const { workflow, editWorkflow } = this.profile;
+      const files = await Promise.all([workflow, editWorkflow].flatMap((f) => f ? [loadWorkflow(f)] : []));
+      return this.reachable(() => this.http.run(async (http) => {
+        for (const file of files)
+          await this.requireInputs(http, file.graph);
+        return [
+          {
+            id: this.defaultModel,
+            name: `${this.defaultModel}, from this profile's workflow files`,
+            capabilities: "reported",
+            inputModalities: editWorkflow ? ["text", "image"] : ["text"],
+            outputModalities: ["image"]
+          }
+        ];
+      }));
+    }
+    flux3KleinModel(this.defaultModel);
+    return this.reachable(() => this.http.run(async (http) => {
+      const models = [];
+      for (const { id, name, upsample } of FLUX3_KLEIN_MODELS)
+        if (!(await this.missingWeights(http, { id, name, upsample })).length)
+          models.push({
+            id,
+            name,
+            capabilities: "reported",
+            inputModalities: ["text", "image"],
+            outputModalities: ["image"]
+          });
+      return models;
+    }));
+  }
+  async run(request, images) {
+    const { count, format } = validateImageRequest(request, images);
+    const plan = this.usesWorkflowFiles ? await this.workflowPlan(request, images) : this.kleinPlan(request);
+    return this.reachable(async () => {
+      await this.http.run((http) => plan.preflight(http));
+      const uploaded = [];
+      for (const image of images)
+        uploaded.push(await this.upload(image));
+      const results = [];
+      for (let i = 0; i < count; i++)
+        results.push(await this.render(plan, uploaded, randomInt(281474976710655), format));
+      return {
+        provider: this.name,
+        requestedModel: plan.model,
+        images: results
+      };
+    });
+  }
+  kleinPlan(request) {
+    const model = flux3KleinModel((request.model ?? this.defaultModel).trim());
+    const steps = flux3KleinSteps(request.quality);
+    const size = comfySize(request.size);
+    return {
+      model: model.id,
+      preflight: async (http) => {
+        const missing = await this.missingWeights(http, model);
+        if (missing.length)
+          throw new ProviderError({
+            kind: "configuration",
+            message: `ComfyUI is missing FLUX 3 Klein weights: ${missing.join(", ")}. Download them from black-forest-labs/flux-3-image-klein-comfy into its models folder.`
+          });
+      },
+      graph: (images, seed) => flux3KleinWorkflow({
+        prompt: request.prompt,
+        upsample: model.upsample,
+        images,
+        size,
+        steps,
+        seed
+      }),
+      described: (outputs, seed) => {
+        const caption = record2(outputs.caption).text;
+        return {
+          prompt: model.upsample && Array.isArray(caption) && typeof caption[0] === "string" ? caption[0] : request.prompt,
+          servedModel: FLUX3_KLEIN_CHECKPOINT,
+          usage: { served: { steps, seed, upsampled: model.upsample } }
+        };
+      }
+    };
+  }
+  async workflowPlan(request, images) {
+    const model = this.defaultModel;
+    if (request.model && request.model.trim() !== model)
+      throw usage(`Profile ${this.name} renders ${model} from its workflow files. Update the profile to change models.`);
+    if ((request.quality ?? "auto").trim().toLowerCase() !== "auto")
+      throw usage("Workflow files set their own sampling, so only --quality auto applies.");
+    const path = images.length ? this.profile.editWorkflow : this.profile.workflow;
+    if (!path)
+      throw usage(images.length ? `Profile ${this.name} has no --edit-workflow, so it cannot take input images.` : `Profile ${this.name} has no --workflow, so it needs a source image.`);
+    const workflow = await loadWorkflow(path);
+    if (workflow.images !== images.length)
+      throw usage(`This workflow takes ${workflow.images} input images, but the request has ${images.length}.`);
+    const requested = comfySize(request.size);
+    if (requested && !workflow.sized)
+      throw usage("This workflow has fixed dimensions, so only --size auto applies.");
+    const size = !workflow.sized ? void 0 : requested ?? (images[0] ? await sourceShape(images[0]) : { width: 1024, height: 1024 });
+    return {
+      model,
+      preflight: (http) => this.requireInputs(http, workflow.graph),
+      graph: (uploaded, seed) => fillWorkflow(workflow, {
+        prompt: request.prompt,
+        seed,
+        size,
+        images: uploaded
+      }),
+      described: (_, seed) => ({
+        prompt: request.prompt,
+        servedModel: model,
+        usage: { served: { seed } }
+      })
+    };
+  }
+  async reachable(action) {
+    try {
+      return await action();
+    } catch (e) {
+      if (e instanceof ProviderError && e.kind === "transport") {
+        const start = this.profile.startCommand;
+        throw new ProviderError({
+          kind: "transport",
+          message: `ComfyUI is not reachable at ${this.baseUrl}. Start it${start ? ` with \`${start}\`` : ""} and retry.`
+        });
+      }
+      throw e;
+    }
+  }
+  // Names what a workflow file needs instead of queueing a doomed job.
+  async requireInputs(http, graph) {
+    const specs = /* @__PURE__ */ new Map();
+    const missing = /* @__PURE__ */ new Set();
+    for (const node of Object.values(graph)) {
+      if (!specs.has(node.class_type)) {
+        const info = await http.json(`${this.baseUrl}/object_info/${encodeURIComponent(node.class_type)}`);
+        specs.set(node.class_type, record2(info[node.class_type]));
+      }
+      const spec = record2(specs.get(node.class_type));
+      if (!Object.keys(spec).length) {
+        missing.add(`node type ${node.class_type}`);
+        continue;
+      }
+      const inputs = {
+        ...record2(record2(spec.input).required),
+        ...record2(record2(spec.input).optional)
+      };
+      for (const [name, value] of Object.entries(node.inputs)) {
+        if (typeof value !== "string" || value.includes("{{"))
+          continue;
+        if (comboOptions(inputs[name])?.includes(value) === false)
+          missing.add(`${value} for ${node.class_type}.${name}`);
+      }
+    }
+    if (missing.size)
+      throw new ProviderError({
+        kind: "configuration",
+        message: `ComfyUI is missing what this workflow needs: ${[...missing].join(", ")}. Install it under ComfyUI, restart the server, and retry.`
+      });
+  }
+  async missingWeights(http, model) {
+    const choices = /* @__PURE__ */ new Map();
+    const missing = [];
+    for (const weight of flux3KleinWeights(model)) {
+      if (!choices.has(weight.node)) {
+        const info = await http.json(`${this.baseUrl}/object_info/${weight.node}`);
+        const inputs = record2(record2(record2(info[weight.node]).input).required);
+        choices.set(weight.node, comboChoices(inputs[weight.input]));
+      }
+      if (!choices.get(weight.node)?.includes(weight.file))
+        missing.push(`${weight.folder}/${weight.file}`);
+    }
+    return missing;
+  }
+  // The temp folder keeps inputs out of ComfyUI's library; it clears on restart.
+  upload(image) {
+    return this.http.run(async (http) => {
+      const form = new FormData();
+      form.set("image", new Blob([new Uint8Array(image.data)], { type: image.contentType }), `imagegen-${randomUUID2()}.${EXTENSIONS[image.contentType]}`);
+      form.set("type", "temp");
+      const body = await http.json(`${this.baseUrl}/upload/image`, {
+        method: "POST",
+        body: form
+      });
+      if (typeof body.name !== "string")
+        throw new ProviderError({
+          kind: "malformed",
+          message: "ComfyUI did not return an uploaded image name."
+        });
+      return `${body.name} [temp]`;
+    });
+  }
+  render(plan, images, seed, format) {
+    return this.http.run(async (http) => {
+      const queued = await http.json(`${this.baseUrl}/prompt`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ prompt: plan.graph(images, seed) })
+      }).catch((e) => {
+        if (e instanceof ProviderError && e.statusCode === 400)
+          throw new ProviderError({
+            kind: "server",
+            statusCode: 400,
+            message: `ComfyUI rejected the ${plan.model} workflow. Check its console for the failing node, and update ComfyUI if a node is unknown.`
+          });
+        throw e;
+      });
+      if (typeof queued.prompt_id !== "string")
+        throw new ProviderError({
+          kind: "malformed",
+          message: "ComfyUI did not return a prompt ID."
+        });
+      const outputs = record2((await this.finished(http, queued.prompt_id)).outputs);
+      const saved = Object.values(outputs).map((output) => record2(output).images).find((list) => Array.isArray(list) && list.length);
+      const file = record2(Array.isArray(saved) ? saved[0] : void 0);
+      if (typeof file.filename !== "string")
+        throw new ProviderError({
+          kind: "no_image",
+          message: "ComfyUI finished without an output image."
+        });
+      const query = new URLSearchParams({
+        filename: file.filename,
+        subfolder: typeof file.subfolder === "string" ? file.subfolder : "",
+        type: typeof file.type === "string" ? file.type : "temp"
+      });
+      const data = await http.bytes(`${this.baseUrl}/view?${query}`);
+      return {
+        ...await encoded(data, format),
+        mimeType: `image/${format}`,
+        responseId: queued.prompt_id,
+        ...plan.described(outputs, seed)
+      };
+    });
+  }
+  async finished(http, id) {
+    for (; ; ) {
+      const history = await http.json(`${this.baseUrl}/history/${id}`);
+      const entry = record2(history[id]);
+      const status = record2(entry.status);
+      if (status.status_str === "error")
+        throw executionFailure(status.messages);
+      if (status.completed === true)
+        return entry;
+      await new Promise((resolve4) => setTimeout(resolve4, this.pollIntervalMs));
+    }
+  }
+};
+
 // ../../packages/providers-configurable/dist/provider.js
 var ConfigurableImageProvider = class {
   getKey;
@@ -1643,19 +2338,12 @@ var ConfigurableImageProvider = class {
     const model = (request.model ?? this.profile.model ?? "").trim();
     if (!model)
       throw usage("Supply --model or configure a default model with providers update.");
-    if ((request.referenceImages?.length ?? 0) > 4)
-      throw usage("At most four reference images are allowed.");
-    const count = request.count ?? 1;
-    if (!Number.isInteger(count) || count < 1 || count > 4)
-      throw usage("Image count must be from 1 to 4.");
     if (mask && this.profile.api === "openrouter")
       throw usage("OpenRouter image API does not expose masks. Describe the edit region in the prompt.");
-    for (const image of [...images, ...mask ? [mask] : []])
-      if (!["image/png", "image/jpeg", "image/webp"].includes(image.contentType))
-        throw usage("Input images must be PNG, JPEG, or WebP.");
-    const format = (request.format ?? "png").trim().toLowerCase().replace(/^jpg$/, "jpeg");
-    if (!["png", "jpeg", "webp"].includes(format))
-      throw usage("Output format must be png, jpeg, or webp.");
+    const { count, format } = validateImageRequest(request, [
+      ...images,
+      ...mask ? [mask] : []
+    ]);
     const quality = request.quality?.trim().toLowerCase();
     if (quality && !/^[a-z][a-z0-9_-]*$/.test(quality))
       throw usage("Quality must be a provider-supported quality name.");
@@ -1713,12 +2401,12 @@ var ConfigurableImageProvider = class {
             message: "Endpoint returned no image bytes or download URL."
           });
         try {
-          const metadata = await sharp3(data).metadata();
+          const metadata = await sharp4(data).metadata();
           if (!metadata.width || !metadata.height || !["png", "jpeg", "webp"].includes(metadata.format ?? "") || typeof image.media_type === "string" && image.media_type !== `image/${metadata.format}`)
             throw new Error();
-          await sharp3(data).stats();
+          await sharp4(data).stats();
           if (metadata.format !== format)
-            data = await sharp3(data).toFormat(format).toBuffer();
+            data = await sharp4(data).toFormat(format).toBuffer();
           return {
             data,
             width: metadata.width,
@@ -1734,12 +2422,15 @@ var ConfigurableImageProvider = class {
           });
         }
       }));
-    return { provider: this.name, imageModel: model, images: results };
+    return { provider: this.name, requestedModel: model, images: results };
   }
 };
+function createProfileProvider(profile) {
+  return profile.api === "comfyui" ? new ComfyUIImageProvider(profile) : new ConfigurableImageProvider(profile, async () => profileKey(profile, await profileStore()));
+}
 function createProfileEntry(profile) {
   return {
-    provider: new ConfigurableImageProvider(profile, async () => profileKey(profile, await profileStore())),
+    provider: createProfileProvider(profile),
     authStatus: async () => {
       let configured = profile.auth === "none";
       if (!configured)
@@ -1827,11 +2518,15 @@ async function readApiKey(fromStdin, input = process.stdin, output = process.std
 
 // src/help.ts
 var PROFILE_HELP = `Named endpoint profiles:
-  imagegen providers add <name> --api <openrouter|openai-images> [--base-url <url>]
-                         [--model <id>] [--auth <bearer|none>]
+  imagegen providers add <name> --api <openrouter|openai-images|comfyui>
+                         [--base-url <url>] [--model <id>] [--auth <bearer|none>]
+                         [--start-command <text>] [--workflow <file>]
+                         [--edit-workflow <file>]
   imagegen providers show <name>
   imagegen providers update <name> [--api <format>] [--base-url <url>]
                          [--model <id>] [--auth <bearer|none>]
+                         [--start-command <text>] [--workflow <file>]
+                         [--edit-workflow <file>]
   imagegen providers remove <name>
   imagegen auth <name> login [--key-stdin]
   imagegen auth <name> status [--show-path]
@@ -1839,8 +2534,9 @@ var PROFILE_HELP = `Named endpoint profiles:
   imagegen models --provider <name>
 
 OpenRouter defaults to https://openrouter.ai/api/v1. openai-images requires
---base-url including the API prefix (e.g. https://api.openai.com/v1).
-Keys use hidden terminal input or explicit --key-stdin and the existing vault/file
+--base-url including the API prefix (e.g. https://api.openai.com/v1). comfyui
+requires --base-url of its server (e.g. http://127.0.0.1:8188) and --model, and
+uses no key. Keys use hidden terminal input or explicit --key-stdin and the existing vault/file
 store. --auth none supports endpoints without keys. Config is saved in providers.json
 alongside the credential file. Origin changes clear the saved key; removing a
 profile removes its credentials. Logout preserves profile configuration.
@@ -1849,13 +2545,25 @@ Select named profiles with --provider. Model precedence: --model > profile defau
 provide one if no default is saved. models explicitly discovers model metadata;
 OpenAI-compatible model listings do not establish image capabilities.
 
-Supported protocols: OpenRouter dedicated Images API and OpenAI Images JSON /
-multipart endpoints, not arbitrary HTTP templates. Options vary by model.
+Supported protocols: OpenRouter dedicated Images API, OpenAI Images JSON /
+multipart endpoints, and local models through ComfyUI, not arbitrary HTTP
+templates. Options vary by model.
 OpenRouter accepts aspect ratios; openai-images needs pixels or presets:
 square 1024x1024, portrait 1024x1536, landscape 1536x1024, wide 1536x864.
 Auto options are omitted. Native masks require openai-images.
 Outputs are measured and converted to PNG/JPEG/WebP without resizing. Count uses
 separate single-image requests without automatic retries or model substitution.
+
+comfyui profiles: --model names what the profile renders. Built in: flux3-klein
+expands the prompt and reports the rendered caption as prompt; flux3-klein-raw
+uses the prompt as the full caption; quality low, medium, and high run 4, 8, and
+16 steps. Any other model needs --workflow (text-to-image) and/or --edit-workflow
+(input images): ComfyUI API-format JSON using {{prompt}} and {{seed}}, optionally
+{{width}} and {{height}}, and {{image1}}, {{image2}}, ... for inputs. Workflow
+files set their own sampling, so only --quality auto applies.
+Sizes accept pixels, presets, or aspect ratios, round to multiples of 16, and need
+edges from 256 to 2048. Masks are rejected. The CLI does not start or stop ComfyUI;
+--start-command records how to start it and is quoted when it is not reachable.
 `;
 var IMAGE_OPTIONS = `Image options (generate, edit):
   --prompt <text>        Prompt text (required)
@@ -1883,34 +2591,41 @@ Gemini provider:
   Model precedence: --model > constructor imageModel > IMAGEGEN_GEMINI_IMAGE_MODEL
   > gemini-nano-banana-2.1. Calls are independent; use prior output as --source.
 
-Supported Codex models (account availability is determined by the provider):
-  gpt-image-2.5-flare     Default; fast image generation and editing
-  gpt-image-2.5-sunburst  Higher-precision image generation and editing
-  gpt-image-2            Previous model; retained for compatibility
+Codex model requests (the backend chooses what actually runs):
+  gpt-image-2.6-flare     Requested by default
+  gpt-image-2.6-sunburst  Requested with --model
+  gpt-image-2.5-flare     Requested with --model
+  gpt-image-2.5-sunburst  Requested with --model
+  gpt-image-2            Requested with --model
 
-Use full model IDs; other provider-supported IDs may also be supplied.
+Codex accepts any model ID, including made-up ones, and does not report what ran;
+its Responses route rewrites these requests to gpt-image-2-codex. Use a named
+profile such as OpenRouter when a specific model matters.
 Model precedence: --model > constructor imageModel (library callers) >
-IMAGEGEN_CODEX_IMAGE_MODEL > gpt-image-2.5-flare.
-Codex may override the requested model, quality, and size; results report the
-returned dimensions. Codex ignores --mask; describe the region in the prompt.
+IMAGEGEN_CODEX_IMAGE_MODEL > gpt-image-2.6-flare.
+JSON results report requestedModel, and servedModel per image (null unless the
+provider names one). Codex also reports served quality, size, and background, and
+may override what was requested. A Codex --mask is sent as the last edit image with a fixed
+instruction appended to the prompt; it steers the edit but does not guarantee
+untouched pixels outside it. It must match the source size, and uses one of the
+four edit-image slots.
 IMAGEGEN_USAGE_LOG=<file> appends one prompt-free JSON usage line per result.
 
-Codex quality: auto (default), low, medium, high; Flare/Sunburst also support
-xhigh and max. gpt-image-2 rejects xhigh/max.
+Codex quality requests: auto (default), low, medium, high; Flare/Sunburst IDs also
+accept xhigh and max. gpt-image-2 rejects xhigh/max. The backend may serve another.
 `;
 var GENERATE_EXAMPLES = `Examples:
   imagegen generate --provider gemini --size 16:9 --prompt "a lighthouse at dawn" --out ./gemini.png
   imagegen generate --prompt "a lighthouse at dawn" --out ./lighthouse.png
-  imagegen generate --model gpt-image-2 --prompt "a lighthouse" --out ./classic.png
-  imagegen generate --model gpt-image-2.5-sunburst --quality max --prompt "a product photo" --out ./product.png
+  imagegen generate --provider openrouter --model openai/gpt-image-2.6-sunburst --quality high --prompt "a product photo" --out ./product.png
 `;
 var EDIT_EXAMPLES = `Edit options:
   --source <file>        Source image (required)
-  --mask <file>          Optional edit mask (openai-images; Codex ignores it)
+  --mask <file>          Optional edit mask; transparent pixels mark the area to edit
 
 Examples:
   imagegen edit --format webp --source ./product.png --prompt "make the product blue" --out ./blue.webp
-  imagegen edit --model gpt-image-2.5-sunburst --quality max --source ./product.png --prompt "add a ribbon" --out ./ribbon.png
+  imagegen edit --provider openrouter --model openai/gpt-image-2.6-sunburst --source ./product.png --prompt "add a ribbon" --out ./ribbon.png
 `;
 var USAGE = `imagegen - provider-agnostic image generation CLI
 
@@ -1928,6 +2643,7 @@ Usage:
   imagegen skill
   imagegen skill install --target <claude|codex|skills-dir> [--target <...>] [--force]
   imagegen help [command]
+  imagegen --version
 
 ${PROFILE_HELP}
 ${IMAGE_OPTIONS}
@@ -1943,6 +2659,7 @@ Auth options:
 
 Global:
   -h, --help             Show help and exit 0
+  --version              Print the CLI version and exit 0
 `;
 var COMMAND_HELP = {
   auth: `imagegen auth - manage provider credentials (one namespace per provider)
@@ -2049,7 +2766,7 @@ ${USAGE}`;
 }
 
 // src/skill.ts
-import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname3, join as join4, resolve } from "node:path";
 var SKILL_NAME = "imagegen-cli";
@@ -2060,7 +2777,7 @@ var SkillExistsError = class extends Error {
   }
 };
 async function skillText() {
-  return readFile2(new URL("../skill/SKILL.md", import.meta.url), "utf8");
+  return readFile3(new URL("../skill/SKILL.md", import.meta.url), "utf8");
 }
 function targetPath(target) {
   const root = target === "claude" ? join4(homedir2(), ".claude", "skills") : target === "codex" ? join4(homedir2(), ".agents", "skills") : resolve(target);
@@ -2068,7 +2785,7 @@ function targetPath(target) {
 }
 async function existingText(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile3(path, "utf8");
   } catch (error2) {
     if (error2.code === "ENOENT") return void 0;
     throw error2;
@@ -2105,7 +2822,7 @@ function usageLogEntry(request, edit, result, paths) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     command: edit ? "edit" : "generate",
     provider: result.provider,
-    imageModel: result.imageModel,
+    requestedModel: result.requestedModel,
     requested: {
       size: request.size ?? "auto",
       quality: request.quality ?? "auto",
@@ -2120,6 +2837,7 @@ function usageLogEntry(request, edit, result, paths) {
       height: image.height,
       bytes: image.data.byteLength,
       responseId: image.responseId,
+      servedModel: image.servedModel ?? null,
       usage: image.usage
     }))
   };
@@ -2156,9 +2874,13 @@ function parseArgs(argv) {
       flags.set("help", true);
       continue;
     }
+    if (arg === "--version") {
+      flags.set("version", true);
+      continue;
+    }
     if (arg.startsWith("--")) {
       const key = arg.slice(2);
-      if (!["prompt", "out", "provider", "model", "reference", "size", "quality", "format", "count", "source", "mask", "timeout", "api", "base-url", "auth", "key-stdin", "no-open", "show-path", "target", "force"].includes(key)) {
+      if (!["prompt", "out", "provider", "model", "reference", "size", "quality", "format", "count", "source", "mask", "timeout", "api", "base-url", "auth", "start-command", "workflow", "edit-workflow", "key-stdin", "no-open", "show-path", "target", "force"].includes(key)) {
         fail("usage", `Unknown option --${key}. Run imagegen help.`, EXIT_USAGE);
       }
       if (key === "key-stdin" || key === "no-open" || key === "show-path" || key === "force") {
@@ -2192,6 +2914,10 @@ function imageModel(flags) {
   if (model !== void 0 && !model) fail("usage", "--model must not be blank.", EXIT_USAGE);
   return model;
 }
+async function cliVersion() {
+  const manifest = JSON.parse(await readFile4(new URL("../package.json", import.meta.url), "utf8"));
+  return manifest.version;
+}
 function redirectUri() {
   return process.env["IMAGEGEN_CODEX_REDIRECT_URI"] ?? DEFAULT_REDIRECT_URI;
 }
@@ -2209,7 +2935,7 @@ function redirectPort(uri) {
 async function loadImageInput(path, label) {
   let data;
   try {
-    data = await readFile3(path);
+    data = await readFile4(path);
   } catch {
     fail("io", `${label} not found: ${path}`, EXIT_IO);
   }
@@ -2286,14 +3012,16 @@ function printResult(providerName, result, paths) {
   process.stdout.write(
     `${JSON.stringify({
       provider: providerName,
-      imageModel: result.imageModel,
+      requestedModel: result.requestedModel,
       images: result.images.map((image, i) => ({
         path: paths[i],
         mimeType: image.mimeType,
         width: image.width,
         height: image.height,
         prompt: image.prompt,
-        responseId: image.responseId
+        responseId: image.responseId,
+        servedModel: image.servedModel ?? null,
+        served: image.usage?.["served"]
       }))
     })}
 `
@@ -2520,6 +3248,11 @@ async function runImageRequest(request, edit, providers) {
 }
 async function main() {
   const { flags, positionals } = parseArgs(process.argv.slice(2));
+  if (flags.get("version")) {
+    process.stdout.write(`${await cliVersion()}
+`);
+    return;
+  }
   if (flags.get("help") || positionals.length === 0) {
     process.stdout.write(helpFor(positionals[0]));
     return;
@@ -2563,10 +3296,14 @@ async function main() {
 `);
       } else if (sub === "add" || sub === "update") {
         const patch = {};
-        for (const [flag, key] of [["api", "api"], ["base-url", "baseUrl"], ["auth", "auth"], ["model", "model"]]) {
+        for (const [flag, key] of [["api", "api"], ["base-url", "baseUrl"], ["auth", "auth"], ["model", "model"], ["start-command", "startCommand"]]) {
           const value = flagValue(flags, flag);
           if (value !== void 0) patch[key] = value;
         }
+        for (const [flag, key] of [["workflow", "workflow"], ["edit-workflow", "editWorkflow"]]) {
+          const value = flagValue(flags, flag);
+          if (value !== void 0) patch[key] = resolve3(value);
+        }
         const profile = sub === "add" ? await repository.add({ name: subSub, ...patch }) : await repository.update(subSub, patch);
         process.stdout.write(`${JSON.stringify({ provider: profile })}
 `);
@@ -2577,8 +3314,7 @@ async function main() {
       const selected = requestedProviders(flags);
       if (!selected || selected.length !== 1) fail("usage", "Model discovery requires exactly one --provider <profile-name>.", EXIT_USAGE);
       const profile = await new ProfileRepository().get(selected[0]);
-      const provider = new ConfigurableImageProvider(profile, async () => profileKey(profile, await profileStore()));
-      process.stdout.write(`${JSON.stringify({ provider: profile.name, models: await provider.models() })}
+      process.stdout.write(`${JSON.stringify({ provider: profile.name, models: await createProfileProvider(profile).models() })}
 `);
       return;
     }