@dorely13/ai-imagegen-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1452 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join as join2, resolve } from "node:path";
+
+// ../../packages/core/dist/types.js
+var ProviderError = class extends Error {
+  kind;
+  statusCode;
+  requestId;
+  responseId;
+  constructor(details) {
+    super(details.message);
+    this.name = "ProviderError";
+    this.kind = details.kind;
+    this.statusCode = details.statusCode;
+    this.requestId = details.requestId;
+    this.responseId = details.responseId;
+  }
+};
+var MAX_REFERENCE_IMAGES = 4;
+var MAX_IMAGE_COUNT = 4;
+var MIN_IMAGE_COUNT = 1;
+
+// ../../packages/core/dist/provider-registry.js
+var ProviderRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  register(entry) {
+    this.entries.set(entry.provider.name, entry);
+  }
+  names() {
+    return [...this.entries.keys()].sort();
+  }
+  get(name) {
+    const entry = this.entries.get(name);
+    if (!entry) {
+      throw new Error(`Unknown provider "${name}". Configured providers: ${this.describe()}.`);
+    }
+    return entry;
+  }
+  async configuredNames() {
+    const names = [];
+    for (const [name, entry] of this.entries) {
+      const status = await entry.authStatus();
+      if (status.configured)
+        names.push(name);
+    }
+    return names.sort();
+  }
+  async resolve(requested) {
+    if (requested && requested.length > 0) {
+      const resolved = requested.map((name) => this.get(name));
+      for (const entry of resolved) {
+        const status = await entry.authStatus();
+        if (!status.configured) {
+          throw new Error(`Provider "${entry.provider.name}" is not configured. ${status.detail ?? "Run its auth command first."}`);
+        }
+      }
+      return resolved;
+    }
+    const configured = await this.configuredNames();
+    if (configured.length === 0) {
+      throw new Error(`No providers are configured. Available providers: ${this.describe()}.`);
+    }
+    if (configured.length > 1) {
+      throw new Error(`Multiple providers are configured (${configured.join(", ")}). Pass --provider to choose one or more.`);
+    }
+    return [this.get(configured[0])];
+  }
+  describe() {
+    const names = this.names();
+    return names.length > 0 ? names.join(", ") : "(none registered)";
+  }
+};
+
+// ../../packages/core/dist/format.js
+function normalizeOutputFormat(value) {
+  const normalized = (value ?? "").trim().toLowerCase();
+  if (normalized === "jpg" || normalized === "jpeg")
+    return "jpeg";
+  if (normalized === "webp")
+    return "webp";
+  return "png";
+}
+
+// ../../packages/core/dist/image-size.js
+var SIZE_MULTIPLE = 16;
+var MINIMUM_PIXELS = 655360;
+var MAXIMUM_PIXELS = 8294400;
+var MAXIMUM_EDGE = 3840;
+var TARGET_PIXELS = 1572864;
+var MAXIMUM_ASPECT_RATIO = 3;
+var PREFERRED_ASPECT_ERROR = 1e-3;
+var SizeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SizeError";
+  }
+};
+function toSize(width, height) {
+  return { width, height, size: `${width}x${height}`, pixels: width * height };
+}
+function targetAspect(width, height) {
+  return validatedAspect(width / height);
+}
+function parseSize(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "" || normalized === "auto")
+    return resolveDefault();
+  if (normalized === "square")
+    return resolveAspect(1);
+  if (normalized === "portrait")
+    return resolveAspect(2 / 3);
+  if (normalized === "landscape")
+    return resolveAspect(3 / 2);
+  if (normalized === "wide" || normalized === "widescreen")
+    return resolveAspect(16 / 9);
+  const match = /^(\d+(?:\.\d+)?)\s*x\s*(\d+(?:\.\d+)?)$/.exec(normalized);
+  if (match) {
+    return resolveNearestPixels(Number(match[1]), Number(match[2]));
+  }
+  const aspect = parseAspect(normalized);
+  return resolveNearestAspect(aspect);
+}
+function parseAspect(value) {
+  const normalized = value.trim().toLowerCase();
+  const ratio = /^(\d+(?:\.\d+)?)\s*[:/]\s*(\d+(?:\.\d+)?)$/.exec(normalized);
+  if (ratio) {
+    const width = Number(ratio[1]);
+    const height = Number(ratio[2]);
+    if (width > 0 && height > 0)
+      return validatedAspect(width / height);
+  }
+  const decimal = Number(normalized);
+  if (Number.isFinite(decimal) && decimal > 0)
+    return validatedAspect(decimal);
+  throw new SizeError(`Invalid size '${value}'. Use WIDTHxHEIGHT, an aspect like 16:9, a preset (square, portrait, landscape, wide), or auto.`);
+}
+function validatedAspect(aspect) {
+  if (!Number.isFinite(aspect) || aspect < 1 / MAXIMUM_ASPECT_RATIO || aspect > MAXIMUM_ASPECT_RATIO) {
+    throw new SizeError("Image aspect ratio must be between 1:3 and 3:1.");
+  }
+  return aspect;
+}
+function resolveDefault() {
+  return resolveAspect(1);
+}
+function resolveAspect(aspect) {
+  const valid = validatedAspect(aspect);
+  const candidates = [];
+  for (let width = SIZE_MULTIPLE; width <= MAXIMUM_EDGE; width += SIZE_MULTIPLE) {
+    const nearestHeight = Math.round(width / valid / SIZE_MULTIPLE) * SIZE_MULTIPLE;
+    for (let offset = -1; offset <= 1; offset += 1) {
+      const height = nearestHeight + offset * SIZE_MULTIPLE;
+      if (height <= 0 || height > MAXIMUM_EDGE)
+        continue;
+      const pixels = width * height;
+      if (pixels < MINIMUM_PIXELS || pixels > MAXIMUM_PIXELS)
+        continue;
+      const actualAspect = width / height;
+      if (actualAspect < 1 / MAXIMUM_ASPECT_RATIO || actualAspect > MAXIMUM_ASPECT_RATIO)
+        continue;
+      candidates.push({
+        width,
+        height,
+        aspectError: Math.abs(Math.log(actualAspect / valid)),
+        areaDistance: Math.abs(pixels - TARGET_PIXELS)
+      });
+    }
+  }
+  if (candidates.length === 0) {
+    throw new SizeError("Could not derive a valid raster size for the requested aspect ratio.");
+  }
+  const exact = candidates.filter((candidate) => candidate.aspectError <= 1e-10);
+  const pool = exact.length > 0 ? exact : candidates.filter((candidate) => candidate.aspectError <= PREFERRED_ASPECT_ERROR);
+  const ranked = (pool.length > 0 ? pool : candidates).sort((a, b) => a.areaDistance - b.areaDistance || a.aspectError - b.aspectError || a.width - b.width || a.height - b.height);
+  const selected = ranked[0];
+  return toSize(selected.width, selected.height);
+}
+function resolveNearestAspect(aspect) {
+  return resolveAspect(aspect);
+}
+function resolveNearestPixels(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    throw new SizeError("Desired image pixels must be finite positive values.");
+  }
+  const aspect = targetAspect(width, height);
+  const candidates = [];
+  for (let candidateWidth = SIZE_MULTIPLE; candidateWidth <= MAXIMUM_EDGE; candidateWidth += SIZE_MULTIPLE) {
+    const nearestHeight = Math.round(candidateWidth / aspect / SIZE_MULTIPLE) * SIZE_MULTIPLE;
+    for (let offset = -1; offset <= 1; offset += 1) {
+      const candidateHeight = nearestHeight + offset * SIZE_MULTIPLE;
+      if (candidateHeight <= 0 || candidateHeight > MAXIMUM_EDGE)
+        continue;
+      const pixels = candidateWidth * candidateHeight;
+      if (pixels < MINIMUM_PIXELS || pixels > MAXIMUM_PIXELS)
+        continue;
+      const actualAspect = candidateWidth / candidateHeight;
+      const aspectError = Math.abs(Math.log(actualAspect / aspect));
+      if (aspectError > PREFERRED_ASPECT_ERROR)
+        continue;
+      candidates.push({
+        width: candidateWidth,
+        height: candidateHeight,
+        aspectError,
+        distance: Math.round((candidateWidth - width) ** 2 + (candidateHeight - height) ** 2)
+      });
+    }
+  }
+  if (candidates.length === 0) {
+    throw new SizeError("Could not derive a provider-valid raster near the requested pixel dimensions.");
+  }
+  const ranked = candidates.sort((a, b) => a.distance - b.distance || a.aspectError - b.aspectError || a.width - b.width || a.height - b.height);
+  const selected = ranked[0];
+  return toSize(selected.width, selected.height);
+}
+
+// ../../packages/providers-codex/dist/codex-constants.js
+var PROVIDER_NAME = "codex";
+var AUTH_ENDPOINT = "https://auth.openai.com/oauth/authorize";
+var TOKEN_ENDPOINT = "https://auth.openai.com/oauth/token";
+var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var SCOPE = "openid profile email offline_access";
+var RESPONSES_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+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";
+var DEFAULT_ORCHESTRATION_MODEL = "gpt-5.6-luna";
+var DEFAULT_QUALITY = "auto";
+var REQUEST_TIMEOUT_SECONDS = 600;
+var PARTIAL_IMAGES = 2;
+var MAX_REFERENCE_IMAGES2 = 4;
+var MAX_IMAGE_COUNT2 = 4;
+var MIN_IMAGE_COUNT2 = 1;
+var FLOW_TIMEOUT_MINUTES = 10;
+var USER_AGENT = "ImageGenCli";
+
+// ../../packages/providers-codex/dist/pkce.js
+import { createHash, randomBytes } from "node:crypto";
+function base64UrlEncode(data) {
+  return Buffer.from(data).toString("base64url");
+}
+function createPkcePair() {
+  const verifier = base64UrlEncode(randomBytes(32));
+  const challenge = base64UrlEncode(createHash("sha256").update(verifier, "ascii").digest());
+  const state = randomBytes(16).toString("hex");
+  return { verifier, challenge, state };
+}
+function buildAuthorizeUrl(pair, redirectUri2) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: CLIENT_ID,
+    redirect_uri: redirectUri2,
+    scope: SCOPE,
+    state: pair.state,
+    code_challenge: pair.challenge,
+    code_challenge_method: "S256",
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    originator: "pi"
+  });
+  return `${AUTH_ENDPOINT}?${params.toString()}`;
+}
+
+// ../../packages/providers-codex/dist/loopback-server.js
+import { createServer } from "node:http";
+var LoopbackError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "LoopbackError";
+    this.code = code;
+  }
+};
+function callbackPage(title, message) {
+  return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body style="font-family:sans-serif;padding:2rem"><h1>${title}</h1><p>${message}</p></body></html>`;
+}
+async function waitForOAuthCallback(timeoutMs = FLOW_TIMEOUT_MINUTES * 60 * 1e3, port = LOOPBACK_PORT) {
+  return new Promise((resolve2, reject) => {
+    let server;
+    const timer = setTimeout(() => {
+      closeServer();
+      reject(new LoopbackError("OAuth flow timed out waiting for the browser callback.", "timeout"));
+    }, timeoutMs);
+    const closeServer = () => {
+      clearTimeout(timer);
+      server?.close();
+    };
+    const fail2 = (error) => {
+      closeServer();
+      reject(error);
+    };
+    server = createServer((req, res) => {
+      try {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        if (url.pathname !== CALLBACK_PATH) {
+          res.writeHead(404, { "content-type": "text/plain" });
+          res.end("Not found.");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+        const errorParam = url.searchParams.get("error");
+        if (errorParam) {
+          res.writeHead(400, { "content-type": "text/html" });
+          res.end(callbackPage("Authorization failed", "The provider returned an error. You can close this tab."));
+          fail2(new LoopbackError("OAuth provider returned an error.", "callback_error"));
+          return;
+        }
+        if (!code || !state) {
+          res.writeHead(400, { "content-type": "text/html" });
+          res.end(callbackPage("Authorization failed", "The callback was missing the authorization code."));
+          fail2(new LoopbackError("OAuth callback was missing the authorization code.", "callback_error"));
+          return;
+        }
+        res.writeHead(200, { "content-type": "text/html" });
+        res.end(callbackPage("Connected", "ImageGenCli is connected. You can close this tab."));
+        closeServer();
+        resolve2({ code, state });
+      } catch (error) {
+        fail2(error instanceof Error ? error : new LoopbackError("OAuth callback failed.", "callback_error"));
+      }
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        fail2(new LoopbackError(`Port ${port} is busy. Close the conflicting process and retry.`, "port_busy"));
+        return;
+      }
+      fail2(error);
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+// ../../packages/providers-codex/dist/codex-auth.js
+var ReauthRequiredError = class extends Error {
+  constructor(message = "Codex credentials are missing or expired. Run `imagegen auth login` to reconnect.") {
+    super(message);
+    this.name = "ReauthRequiredError";
+  }
+};
+function toTokenSet(body, fallbackRefreshToken) {
+  return {
+    accessToken: body.access_token,
+    refreshToken: body.refresh_token ?? fallbackRefreshToken,
+    expiresAt: Date.now() + body.expires_in * 1e3,
+    scope: body.scope
+  };
+}
+async function readOAuthErrorCode(response) {
+  try {
+    const body = await response.json();
+    return typeof body.error === "string" ? body.error : null;
+  } catch {
+    return null;
+  }
+}
+async function postTokenRequest(params) {
+  const response = await fetch(TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params)
+  });
+  if (!response.ok) {
+    const errorCode = await readOAuthErrorCode(response.clone());
+    if (response.status === 401 || response.status === 400 && (errorCode === "invalid_grant" || errorCode === "invalid_token")) {
+      return null;
+    }
+    throw new Error(`Token request failed with status ${response.status}.`);
+  }
+  const body = await response.json();
+  return toTokenSet(body, params["refresh_token"]);
+}
+async function exchangeCodeForTokens(args) {
+  const tokens = await postTokenRequest({
+    grant_type: "authorization_code",
+    client_id: CLIENT_ID,
+    code: args.code,
+    redirect_uri: args.redirectUri,
+    code_verifier: args.codeVerifier
+  });
+  if (!tokens) {
+    throw new ReauthRequiredError("The authorization code was rejected. Run `imagegen auth login` again.");
+  }
+  return tokens;
+}
+async function refreshTokens(refreshToken) {
+  return postTokenRequest({
+    grant_type: "refresh_token",
+    client_id: CLIENT_ID,
+    refresh_token: refreshToken
+  });
+}
+function isTokenExpired(tokens, now = Date.now()) {
+  return tokens.expiresAt <= now;
+}
+var pendingVerifiers = /* @__PURE__ */ new Map();
+function startPkceFlow(redirectUri2) {
+  const pair = createPkcePair();
+  prunePendingVerifiers();
+  pendingVerifiers.set(pair.state, { verifier: pair.verifier, createdAt: Date.now() });
+  return { url: buildAuthorizeUrl(pair, redirectUri2), state: pair.state };
+}
+function consumeVerifier(state) {
+  const entry = pendingVerifiers.get(state);
+  pendingVerifiers.delete(state);
+  if (!entry)
+    return null;
+  if (Date.now() - entry.createdAt > FLOW_TIMEOUT_MINUTES * 60 * 1e3)
+    return null;
+  return entry.verifier;
+}
+function prunePendingVerifiers() {
+  const cutoff = Date.now() - FLOW_TIMEOUT_MINUTES * 60 * 1e3;
+  for (const [state, entry] of pendingVerifiers) {
+    if (entry.createdAt < cutoff)
+      pendingVerifiers.delete(state);
+  }
+}
+
+// ../../packages/providers-codex/dist/codex-token-manager.js
+var CodexTokenManager = class {
+  store;
+  pendingRefresh = null;
+  constructor(store) {
+    this.store = store;
+  }
+  async exchangeAndSave(args) {
+    const tokens = await exchangeCodeForTokens(args);
+    await this.store.save(PROVIDER_NAME, tokens);
+    return tokens;
+  }
+  async status() {
+    const tokens = await this.store.load(PROVIDER_NAME);
+    if (!tokens)
+      return { connected: false };
+    if (!isTokenExpired(tokens))
+      return { connected: true, expiresAt: tokens.expiresAt };
+    if (!tokens.refreshToken)
+      return { connected: false };
+    try {
+      const refreshed = await this.getValidAccessToken();
+      void refreshed;
+      const current = await this.store.load(PROVIDER_NAME);
+      return { connected: true, expiresAt: current?.expiresAt };
+    } catch {
+      return { connected: false };
+    }
+  }
+  async logout() {
+    await this.store.clear(PROVIDER_NAME);
+  }
+  async getValidAccessToken() {
+    const tokens = await this.store.load(PROVIDER_NAME);
+    if (!tokens)
+      throw new ReauthRequiredError();
+    if (!isTokenExpired(tokens))
+      return tokens.accessToken;
+    if (!tokens.refreshToken) {
+      await this.store.clear(PROVIDER_NAME);
+      throw new ReauthRequiredError();
+    }
+    if (!this.pendingRefresh) {
+      this.pendingRefresh = this.performRefresh(tokens.refreshToken).finally(() => {
+        this.pendingRefresh = null;
+      });
+    }
+    return this.pendingRefresh;
+  }
+  async performRefresh(refreshToken) {
+    const refreshed = await refreshTokens(refreshToken);
+    if (!refreshed) {
+      await this.store.clear(PROVIDER_NAME);
+      throw new ReauthRequiredError();
+    }
+    await this.store.save(PROVIDER_NAME, refreshed);
+    return refreshed.accessToken;
+  }
+};
+
+// ../../packages/providers-codex/dist/token-store.js
+import { homedir } from "node:os";
+import { join } from "node:path";
+function asKeytar(module) {
+  if (typeof module !== "object" || module === null)
+    return null;
+  const record = module;
+  const candidate = record["default"] ?? module;
+  if (typeof candidate.getPassword === "function" && typeof candidate.setPassword === "function" && typeof candidate.deletePassword === "function") {
+    return candidate;
+  }
+  return null;
+}
+async function resolveTokenStore() {
+  try {
+    const keytar = asKeytar(await import("keytar"));
+    if (!keytar)
+      return new FileTokenStore();
+    const store = new KeytarTokenStore(keytar);
+    await store.probe();
+    return store;
+  } catch {
+    return new FileTokenStore();
+  }
+}
+var KeytarTokenStore = class {
+  keytar;
+  constructor(keytar) {
+    this.keytar = keytar;
+  }
+  async probe() {
+    await this.keytar.getPassword("ImageGenCli", "__probe__");
+  }
+  async load(provider) {
+    const raw = await this.keytar.getPassword("ImageGenCli", provider);
+    if (!raw)
+      return null;
+    return JSON.parse(raw);
+  }
+  async save(provider, tokens) {
+    await this.keytar.setPassword("ImageGenCli", provider, JSON.stringify(tokens));
+  }
+  async clear(provider) {
+    await this.keytar.deletePassword("ImageGenCli", provider);
+  }
+  describe() {
+    return { backend: "vault", location: "OS credential vault (service ImageGenCli)" };
+  }
+};
+var FileTokenStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath ?? defaultTokenFilePath();
+  }
+  async load(provider) {
+    const all = await this.readAll();
+    return all[provider] ?? null;
+  }
+  async save(provider, tokens) {
+    const all = await this.readAll();
+    all[provider] = tokens;
+    await this.writeAll(all);
+  }
+  async clear(provider) {
+    const all = await this.readAll();
+    delete all[provider];
+    await this.writeAll(all);
+  }
+  describe() {
+    return { backend: "file", location: this.filePath };
+  }
+  async readAll() {
+    const { readFile: readFile2 } = await import("node:fs/promises");
+    try {
+      const raw = await readFile2(this.filePath, "utf8");
+      return JSON.parse(raw);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return {};
+      throw error;
+    }
+  }
+  async writeAll(all) {
+    const { mkdir: mkdir2, writeFile: writeFile2, chmod } = await import("node:fs/promises");
+    const { dirname: dirname2 } = await import("node:path");
+    await mkdir2(dirname2(this.filePath), { recursive: true });
+    await writeFile2(this.filePath, JSON.stringify(all, null, 2), { mode: 384 });
+    if (process.platform !== "win32") {
+      await chmod(this.filePath, 384);
+    }
+  }
+};
+function defaultTokenFilePath() {
+  if (process.platform === "win32") {
+    const base2 = process.env["LOCALAPPDATA"] ?? join(process.env["USERPROFILE"] ?? ".", "AppData", "Local");
+    return join(base2, "ImageGenCli", "tokens.json");
+  }
+  const base = process.env["XDG_DATA_HOME"] ?? join(homedir(), ".local", "share");
+  return join(base, "ImageGenCli", "tokens.json");
+}
+
+// ../../packages/providers-codex/dist/account-id.js
+function extractAccountId(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("OAuth token is not a valid JWT. Run `imagegen auth login` to reconnect.");
+  }
+  let payload;
+  try {
+    const decoded = Buffer.from(parts[1], "base64url").toString("utf8");
+    payload = JSON.parse(decoded);
+  } catch {
+    throw new Error("OAuth token payload could not be decoded. Run `imagegen auth login` to reconnect.");
+  }
+  const accountId = typeof payload === "object" && payload !== null && "https://api.openai.com/auth" in payload && typeof payload["https://api.openai.com/auth"] === "object" && payload["https://api.openai.com/auth"] !== null ? payload["https://api.openai.com/auth"]["chatgpt_account_id"] : void 0;
+  if (typeof accountId !== "string" || accountId.length === 0) {
+    throw new Error("OAuth token does not contain a ChatGPT account id. Run `imagegen auth login` to reconnect.");
+  }
+  return accountId;
+}
+
+// ../../packages/providers-codex/dist/sse.js
+function classifyImageError(message) {
+  if (!message.trim())
+    return "unknown";
+  const lowerRate = message.includes("input-images") && message.includes("per min") && message.toLowerCase().includes("gpt-image");
+  if (lowerRate)
+    return "codex_image_input_rate_limit";
+  if (/rate limit|429|too many requests|please try again/i.test(message))
+    return "rate_limit";
+  if (/403|forbidden|cloudflare/i.test(message))
+    return "codex_transport_forbidden";
+  if (/invalid_value/i.test(message) && /gpt-image/i.test(message))
+    return "image_model_invalid";
+  return "api_error";
+}
+function readString(value, property) {
+  if (typeof value !== "object" || value === null)
+    return void 0;
+  const candidate = value[property];
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function readEventError(event) {
+  const direct = readString(event, "message");
+  if (direct)
+    return direct;
+  if (typeof event !== "object" || event === null)
+    return void 0;
+  const record = event;
+  const nested = record["error"];
+  if (typeof nested === "object" && nested !== null) {
+    const message = readString(nested, "message");
+    if (message)
+      return message;
+  }
+  const response = record["response"];
+  if (typeof response === "object" && response !== null) {
+    const responseError = response["error"];
+    if (typeof responseError === "object" && responseError !== null) {
+      return readString(responseError, "message");
+    }
+  }
+  return void 0;
+}
+function tryReadImageItem(item) {
+  if (readString(item, "type") !== "image_generation_call")
+    return null;
+  const result = readString(item, "result");
+  if (!result)
+    return null;
+  let data;
+  try {
+    data = Buffer.from(result, "base64");
+  } catch {
+    throw new Error("invalid_image_result: Codex returned an image result that was not valid base64.");
+  }
+  return { data, revisedPrompt: readString(item, "revised_prompt"), callId: readString(item, "id") };
+}
+function parseImageStreamEvents(events) {
+  let eventCount = 0;
+  let lastEventType;
+  let responseId;
+  const finish = (image) => ({
+    ...image,
+    responseId,
+    eventCount,
+    lastEventType
+  });
+  for (const raw of events) {
+    const line = raw.trim();
+    if (!line.startsWith("data:"))
+      continue;
+    const payload = line.slice("data:".length).trim();
+    if (payload === "[DONE]")
+      break;
+    let event;
+    try {
+      event = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    const type = readString(event, "type");
+    lastEventType = type ?? lastEventType;
+    eventCount += 1;
+    if (type === "response.created" && typeof event === "object" && event !== null) {
+      const inner = event["response"];
+      const id = readString(inner, "id");
+      if (id)
+        responseId = id;
+    }
+    if (type === "response.failed" || type === "error") {
+      throw new Error(`${classifyImageError(readEventError(event) ?? "")}: ${readEventError(event) ?? "Codex image generation failed."}`);
+    }
+    if (type === "response.output_item.done" && typeof event === "object" && event !== null) {
+      const item = event["item"];
+      const image = tryReadImageItem(item);
+      if (image)
+        return finish(image);
+    }
+    if (type === "response.completed" && typeof event === "object" && event !== null) {
+      const response = event["response"];
+      const id = readString(response, "id");
+      if (id)
+        responseId = id;
+      if (typeof response === "object" && response !== null) {
+        const output = response["output"];
+        if (Array.isArray(output)) {
+          for (const item of output) {
+            const image = tryReadImageItem(item);
+            if (image)
+              return finish(image);
+          }
+        }
+      }
+    }
+  }
+  throw new Error(`stream_completed_without_image: Codex image generation completed without returning an image. responseId=${responseId ?? "unknown"}, events=${eventCount}, lastEvent=${lastEventType ?? "none"}.`);
+}
+
+// ../../packages/providers-codex/dist/codex-client.js
+function toDataUrl(image) {
+  return `data:${image.contentType};base64,${Buffer.from(image.data).toString("base64")}`;
+}
+function normalizeCount(count) {
+  if (!count)
+    return 1;
+  return Math.min(MAX_IMAGE_COUNT2, Math.max(MIN_IMAGE_COUNT2, Math.trunc(count)));
+}
+function resolveSize(size) {
+  try {
+    return parseSize(size ?? "auto");
+  } catch (error) {
+    throw new ProviderError({
+      kind: "usage",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function baseImageTool(args) {
+  const tool = {
+    type: "image_generation",
+    model: args.imageModel,
+    action: args.action,
+    size: args.size && args.size.trim() ? args.size.trim() : "auto",
+    output_format: args.outputFormat,
+    background: "auto"
+  };
+  if (args.partialImages > 0)
+    tool["partial_images"] = Math.min(3, Math.max(0, args.partialImages));
+  if (args.quality && args.quality.trim() && args.quality.trim().toLowerCase() !== "auto") {
+    tool["quality"] = args.quality.trim();
+  }
+  if (args.outputFormat === "jpeg" && typeof args.outputCompression === "number") {
+    tool["output_compression"] = Math.min(100, Math.max(0, Math.trunc(args.outputCompression)));
+  }
+  return tool;
+}
+function buildPayload(args) {
+  const content = [{ type: "input_text", text: args.prompt }];
+  for (const reference of args.references.slice(0, MAX_REFERENCE_IMAGES2)) {
+    content.push({ type: "input_image", image_url: toDataUrl(reference), detail: "auto" });
+  }
+  return {
+    model: args.model,
+    input: [{ role: "user", content }],
+    tools: [args.tool],
+    tool_choice: { type: "image_generation" },
+    stream: true,
+    store: false
+  };
+}
+var CodexImageProvider = class {
+  tokens;
+  name = PROVIDER_NAME;
+  sizePolicy = { resolveSize: (size) => resolveSize(size) };
+  orchestrationModel;
+  imageModel;
+  timeoutSeconds;
+  partialImages;
+  fetchImpl;
+  constructor(tokens, options = {}) {
+    this.tokens = tokens;
+    this.orchestrationModel = options.model ?? process.env["IMAGEGEN_CODEX_MODEL"] ?? DEFAULT_ORCHESTRATION_MODEL;
+    this.imageModel = options.imageModel ?? process.env["IMAGEGEN_CODEX_IMAGE_MODEL"] ?? DEFAULT_IMAGE_MODEL;
+    this.timeoutSeconds = options.timeoutSeconds ?? REQUEST_TIMEOUT_SECONDS;
+    this.partialImages = options.partialImages ?? PARTIAL_IMAGES;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async generate(request) {
+    const format = normalizeOutputFormat(request.format);
+    const size = this.sizePolicy.resolveSize(request.size);
+    return this.runAll({
+      format,
+      count: normalizeCount(request.count),
+      prompt: request.prompt,
+      size,
+      build: () => buildPayload({
+        model: this.orchestrationModel,
+        prompt: request.prompt,
+        references: request.referenceImages ?? [],
+        tool: baseImageTool({
+          size: size.size,
+          quality: request.quality ?? DEFAULT_QUALITY,
+          outputFormat: format,
+          imageModel: this.imageModel,
+          action: "generate",
+          partialImages: this.partialImages
+        })
+      })
+    });
+  }
+  async edit(request) {
+    const format = normalizeOutputFormat(request.format);
+    const size = this.sizePolicy.resolveSize(request.size);
+    const references = [request.sourceImage, ...request.referenceImages ?? []];
+    return this.runAll({
+      format,
+      count: normalizeCount(request.count),
+      prompt: request.prompt,
+      size,
+      build: () => {
+        const tool = baseImageTool({
+          size: size.size,
+          quality: request.quality ?? DEFAULT_QUALITY,
+          outputFormat: format,
+          imageModel: this.imageModel,
+          action: "edit",
+          partialImages: this.partialImages
+        });
+        if (request.mask) {
+          tool["input_image_mask"] = { image_url: toDataUrl(request.mask) };
+        }
+        return buildPayload({
+          model: this.orchestrationModel,
+          prompt: request.prompt,
+          references,
+          tool
+        });
+      }
+    });
+  }
+  async runAll(args) {
+    const images = [];
+    for (let i = 0; i < args.count; i += 1) {
+      images.push(await this.sendOnce(args.build(), args.format, args.prompt, args.size));
+    }
+    return { provider: this.name, imageModel: this.imageModel, images };
+  }
+  async sendOnce(payload, format, prompt, size) {
+    const accessToken = await this.tokens.getValidAccessToken();
+    const accountId = extractAccountId(accessToken);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutSeconds * 1e3);
+    let response;
+    try {
+      response = await this.fetchImpl(RESPONSES_ENDPOINT, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+          "chatgpt-account-id": accountId,
+          "OpenAI-Beta": "responses=experimental",
+          originator: "pi",
+          "user-agent": USER_AGENT,
+          accept: "text/event-stream",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const requestId = response.headers.get("x-request-id") ?? response.headers.get("openai-request-id") ?? response.headers.get("request-id") ?? void 0;
+    if (!response.ok || !response.body) {
+      const body = await response.text().catch(() => "");
+      const kind = classifyImageError(body);
+      const detail = readErrorMessage(body);
+      throw new ProviderError({
+        kind,
+        message: detail ? `Codex image request returned ${response.status} (${kind}): ${detail}` : `Codex image request returned ${response.status} (${kind}).`,
+        statusCode: response.status,
+        requestId
+      });
+    }
+    const lines = await readSseLines(response.body);
+    let parsed;
+    try {
+      parsed = parseImageStreamEvents(lines);
+    } catch (error) {
+      throw toProviderError(error, requestId);
+    }
+    return {
+      data: parsed.data,
+      mimeType: `image/${format}`,
+      width: size.width,
+      height: size.height,
+      prompt,
+      responseId: parsed.responseId,
+      callId: parsed.callId
+    };
+  }
+};
+async function readSseLines(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const lines = [];
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    let index = buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      if (line.startsWith("data:"))
+        lines.push(line);
+      index = buffer.indexOf("\n");
+    }
+  }
+  if (buffer.startsWith("data:"))
+    lines.push(buffer);
+  return lines;
+}
+function readErrorMessage(body) {
+  if (!body.trim())
+    return null;
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null) {
+      const record = parsed;
+      if (typeof record["message"] === "string")
+        return record["message"];
+      if (typeof record["detail"] === "string")
+        return record["detail"];
+      const error = record["error"];
+      if (typeof error === "object" && error !== null && typeof error["message"] === "string") {
+        return error["message"];
+      }
+    }
+  } catch {
+    return body.slice(0, 500);
+  }
+  return null;
+}
+function toProviderError(error, requestId) {
+  const message = error instanceof Error ? error.message : String(error);
+  const separator = message.indexOf(":");
+  const kind = separator > 0 ? message.slice(0, separator) : "api_error";
+  return new ProviderError({ kind, message, requestId });
+}
+
+// ../../packages/providers-codex/dist/codex-entry.js
+function createCodexEntry() {
+  const buildProvider = async () => {
+    const store = await resolveTokenStore();
+    return new CodexImageProvider(new CodexTokenManager(store));
+  };
+  const authStatus = async () => {
+    const store = await resolveTokenStore();
+    const manager = new CodexTokenManager(store);
+    const status = await manager.status();
+    return {
+      name: PROVIDER_NAME,
+      configured: status.connected,
+      detail: status.connected ? void 0 : "Run `imagegen auth codex login` to connect."
+    };
+  };
+  let sizePolicy;
+  return {
+    provider: {
+      name: PROVIDER_NAME,
+      get sizePolicy() {
+        if (!sizePolicy)
+          throw new Error("Codex provider is not initialized.");
+        return sizePolicy;
+      },
+      generate: async (request) => {
+        const provider = await buildProvider();
+        sizePolicy = provider.sizePolicy;
+        return provider.generate(request);
+      },
+      edit: async (request) => {
+        const provider = await buildProvider();
+        sizePolicy = provider.sizePolicy;
+        return provider.edit(request);
+      }
+    },
+    authStatus
+  };
+}
+
+// src/help.ts
+var USAGE = `imagegen - provider-agnostic image generation CLI
+
+Usage:
+  imagegen auth codex login [--timeout <minutes>] [--no-open]
+  imagegen auth codex status [--show-path]
+  imagegen auth codex logout
+  imagegen generate --prompt <text> --out <path|dir> [--provider <name>] [options]
+  imagegen edit --prompt <text> --source <file> [--mask <file>] --out <path|dir> [--provider <name>] [options]
+  imagegen providers
+  imagegen help [command]
+
+Image options (generate, edit):
+  --prompt <text>        Prompt text (required)
+  --out <path|dir>       Output file or directory (required)
+  --provider <name>      Repeatable. Defaults to the only configured provider;
+                         required when several are configured.
+  --reference <file>     Reference image for continuity (repeatable, max 4)
+  --size <size>          auto, WIDTHxHEIGHT, aspect (16:9), or preset
+                     square, portrait, landscape, wide (validated per
+                     provider; bad aspects are rejected)
+  --quality <quality>    Quality hint (provider-specific, default auto)
+  --format <format>      png, jpeg, or webp (default png)
+  --count <n>            Number of images, 1-4 (default 1)
+
+Auth options:
+  --timeout <minutes>    Login wait timeout (default 10)
+  --no-open              Print the URL without opening a browser
+  --show-path            Show where tokens are stored (auth status)
+
+Global:
+  -h, --help             Show help and exit 0
+`;
+var COMMAND_HELP = {
+  auth: `imagegen auth - manage provider credentials (one namespace per provider)
+
+Usage:
+  imagegen auth codex login [--timeout <minutes>] [--no-open]
+  imagegen auth codex status [--show-path]
+  imagegen auth codex logout
+`,
+  login: `imagegen auth codex login - connect Codex via browser OAuth
+
+Usage:
+  imagegen auth codex login [--timeout <minutes>] [--no-open]
+
+Starts a temporary localhost callback server, opens the browser,
+exchanges the code, and stores tokens in the OS vault (file fallback).
+`,
+  status: `imagegen auth codex status - show Codex connection state
+
+Usage:
+  imagegen auth codex status [--show-path]
+
+Prints JSON without secrets. --show-path reveals the token location.
+`,
+  logout: `imagegen auth codex logout - remove stored Codex credentials
+
+Usage:
+  imagegen auth codex logout
+`,
+  generate: `imagegen generate - create images from a prompt
+
+Usage:
+  imagegen generate --prompt <text> --out <path|dir> [--provider <name>] [options]
+
+Options: --provider <name> (repeatable; run on several providers),
+--reference <file> (repeatable, max 4), --size, --quality,
+--format png|jpeg|webp, --count 1-4.
+`,
+  edit: `imagegen edit - edit a source image with a prompt
+
+Usage:
+  imagegen edit --prompt <text> --source <file> [--mask <file>] --out <path|dir> [--provider <name>] [options]
+
+Same image options as generate.
+`,
+  providers: `imagegen providers - list registered and configured providers
+
+Usage:
+  imagegen providers
+
+Prints JSON with each provider and whether it is configured.
+`,
+  help: `imagegen help - show human-readable usage
+
+Usage:
+  imagegen help [command]
+`
+};
+function helpFor(topic) {
+  if (!topic) return USAGE;
+  const text = COMMAND_HELP[topic];
+  if (!text) return `Unknown help topic "${topic}".
+
+${USAGE}`;
+  return text;
+}
+
+// src/index.ts
+var EXIT_USAGE = 2;
+var EXIT_AUTH = 3;
+var EXIT_PROVIDER = 4;
+var EXIT_IO = 5;
+function fail(kind, message, exitCode) {
+  process.stderr.write(`${JSON.stringify({ error: { kind, message } })}
+`);
+  process.exit(exitCode);
+}
+function parseArgs(argv) {
+  const flags = /* @__PURE__ */ new Map();
+  const positionals = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      flags.set("help", true);
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (key === "no-open" || key === "show-path") {
+        flags.set(key, true);
+        continue;
+      }
+      if (key === "reference" || key === "provider") {
+        const value2 = argv[i + 1];
+        if (!value2 || value2.startsWith("--")) fail("usage", `Missing value for --${key}.`, EXIT_USAGE);
+        i += 1;
+        const existing = flags.get(key);
+        flags.set(key, [...Array.isArray(existing) ? existing : [], value2]);
+        continue;
+      }
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) fail("usage", `Missing value for --${key}.`, EXIT_USAGE);
+      i += 1;
+      flags.set(key, value);
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return { flags, positionals };
+}
+function flagValue(flags, key) {
+  const value = flags.get(key);
+  return typeof value === "string" ? value : void 0;
+}
+function redirectUri() {
+  return process.env["IMAGEGEN_CODEX_REDIRECT_URI"] ?? DEFAULT_REDIRECT_URI;
+}
+function redirectPort(uri) {
+  try {
+    const parsed = new URL(uri);
+    if (parsed.hostname !== "localhost" && parsed.hostname !== "127.0.0.1") {
+      fail("usage", "Custom redirect URI must use localhost.", EXIT_USAGE);
+    }
+    return parsed.port ? Number(parsed.port) : LOOPBACK_PORT;
+  } catch {
+    fail("usage", "IMAGEGEN_CODEX_REDIRECT_URI is not a valid URL.", EXIT_USAGE);
+  }
+}
+async function loadImageInput(path, label) {
+  let data;
+  try {
+    data = await readFile(path);
+  } catch {
+    fail("io", `${label} not found: ${path}`, EXIT_IO);
+  }
+  return { data: new Uint8Array(data), contentType: contentTypeFor(path), filename: basename(path) };
+}
+function contentTypeFor(path) {
+  switch (extname(path).toLowerCase()) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".png":
+      return "image/png";
+    default:
+      return "image/png";
+  }
+}
+async function loadReferences(flags) {
+  const raw = flags.get("reference");
+  const paths = Array.isArray(raw) ? raw : [];
+  if (paths.length > MAX_REFERENCE_IMAGES) {
+    fail("usage", `At most ${MAX_REFERENCE_IMAGES} --reference images are allowed.`, EXIT_USAGE);
+  }
+  const images = [];
+  for (const path of paths) {
+    images.push(await loadImageInput(path, "Reference image"));
+  }
+  return images;
+}
+function parseCount(flags) {
+  const raw = flagValue(flags, "count");
+  if (!raw) return 1;
+  const count = Number(raw);
+  if (!Number.isInteger(count) || count < MIN_IMAGE_COUNT || count > MAX_IMAGE_COUNT) {
+    fail("usage", `--count must be an integer from ${MIN_IMAGE_COUNT} to ${MAX_IMAGE_COUNT}.`, EXIT_USAGE);
+  }
+  return count;
+}
+function registry() {
+  const registry2 = new ProviderRegistry();
+  registry2.register(createCodexEntry());
+  return registry2;
+}
+function requestedProviders(flags) {
+  const raw = flags.get("provider");
+  if (!Array.isArray(raw) || raw.length === 0) return void 0;
+  return raw;
+}
+async function resolveOutPaths(out, providerName, multiProvider, count, format) {
+  const resolved = resolve(out);
+  let isDir = false;
+  try {
+    const info = await stat(resolved);
+    isDir = info.isDirectory();
+  } catch {
+    isDir = extname(resolved) === "";
+  }
+  const extension = `.${normalizeOutputFormat(format)}`;
+  const prefix = multiProvider ? `${providerName}-` : "";
+  if (isDir) {
+    return Array.from({ length: count }, (_, i) => join2(resolved, `${prefix}image-${i + 1}${extension}`));
+  }
+  if (count > 1 || multiProvider) {
+    const dir = dirname(resolved);
+    const base = basename(resolved, extname(resolved));
+    return Array.from({ length: count }, (_, i) => join2(dir, `${prefix}${base}-${i + 1}${extension}`));
+  }
+  return [resolved.endsWith(extension) ? resolved : `${resolved}${extension}`];
+}
+function printResult(providerName, result, paths) {
+  process.stdout.write(
+    `${JSON.stringify({
+      provider: providerName,
+      imageModel: result.imageModel,
+      images: result.images.map((image, i) => ({
+        path: paths[i],
+        mimeType: image.mimeType,
+        width: image.width,
+        height: image.height,
+        prompt: image.prompt,
+        responseId: image.responseId
+      }))
+    })}
+`
+  );
+}
+async function saveImages(result, paths) {
+  for (let i = 0; i < result.images.length; i += 1) {
+    const path = paths[i];
+    try {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, Buffer.from(result.images[i].data));
+    } catch {
+      fail("io", `Could not write output file: ${path}`, EXIT_IO);
+    }
+  }
+}
+async function runAuthLogin(providerName, flags) {
+  if (providerName !== PROVIDER_NAME) {
+    fail("usage", `Unknown auth provider "${providerName}". Available: ${registry().describe()}.`, EXIT_USAGE);
+  }
+  const uri = redirectUri();
+  const port = redirectPort(uri);
+  const timeoutMinutes = Number(flagValue(flags, "timeout") ?? "10");
+  if (!Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0 || timeoutMinutes > 60) {
+    fail("usage", "--timeout must be a number of minutes from 1 to 60.", EXIT_USAGE);
+  }
+  const { url, state } = startPkceFlow(uri);
+  let callback;
+  const waiter = waitForOAuthCallback(timeoutMinutes * 60 * 1e3, port);
+  if (!flags.get("no-open")) {
+    try {
+      const { default: open } = await import("open");
+      await open(url);
+    } catch {
+      process.stderr.write("Could not open a browser automatically. Open this URL manually:\n");
+    }
+  }
+  process.stderr.write(`Authorize in the browser:
+${url}
+`);
+  try {
+    callback = await waiter;
+  } catch (error) {
+    if (error instanceof LoopbackError) fail("auth", error.message, EXIT_AUTH);
+    throw error;
+  }
+  if (callback.state !== state) fail("auth", "OAuth state mismatch. Retry `imagegen auth codex login`.", EXIT_AUTH);
+  const verifier = consumeVerifier(state);
+  if (!verifier) fail("auth", "OAuth flow expired. Retry `imagegen auth codex login`.", EXIT_AUTH);
+  const store = await resolveTokenStore();
+  if (store.describe().backend === "file") {
+    process.stderr.write("Warning: OS vault unavailable; tokens stored in a restricted file. Use `auth status --show-path` to inspect.\n");
+  }
+  const manager = new CodexTokenManager(store);
+  try {
+    await manager.exchangeAndSave({ code: callback.code, redirectUri: uri, codeVerifier: verifier });
+  } catch (error) {
+    if (error instanceof ReauthRequiredError) fail("auth", error.message, EXIT_AUTH);
+    throw error;
+  }
+  process.stdout.write(`${JSON.stringify({ provider: PROVIDER_NAME, status: "connected" })}
+`);
+}
+async function runProviders() {
+  const entries = registry().names().map((name) => registry().get(name));
+  const providers = [];
+  for (const entry of entries) {
+    const status = await entry.authStatus();
+    providers.push({ name: status.name, configured: status.configured });
+  }
+  process.stdout.write(`${JSON.stringify({ providers })}
+`);
+}
+async function runAuthStatus(providerName, flags) {
+  if (providerName !== PROVIDER_NAME) {
+    fail("usage", `Unknown auth provider "${providerName}". Available: ${registry().describe()}.`, EXIT_USAGE);
+  }
+  const store = await resolveTokenStore();
+  const manager = new CodexTokenManager(store);
+  const status = await manager.status();
+  const output = { provider: PROVIDER_NAME, connected: status.connected };
+  if (status.expiresAt) output["expiresAt"] = new Date(status.expiresAt).toISOString();
+  if (flags.get("show-path")) {
+    const info = store.describe();
+    output["store"] = { backend: info.backend, location: info.location };
+  }
+  process.stdout.write(`${JSON.stringify(output)}
+`);
+}
+async function runAuthLogout(providerName) {
+  if (providerName !== PROVIDER_NAME) {
+    fail("usage", `Unknown auth provider "${providerName}". Available: ${registry().describe()}.`, EXIT_USAGE);
+  }
+  const store = await resolveTokenStore();
+  await store.clear(PROVIDER_NAME);
+  process.stdout.write(`${JSON.stringify({ provider: PROVIDER_NAME, status: "disconnected" })}
+`);
+}
+async function runGenerate(flags) {
+  const prompt = flagValue(flags, "prompt");
+  const out = flagValue(flags, "out");
+  if (!prompt) fail("usage", "Missing required --prompt.", EXIT_USAGE);
+  if (!out) fail("usage", "Missing required --out.", EXIT_USAGE);
+  const providers = await resolveProviders(requestedProviders(flags));
+  const request = {
+    prompt,
+    out,
+    size: flagValue(flags, "size"),
+    quality: flagValue(flags, "quality"),
+    format: flagValue(flags, "format"),
+    count: parseCount(flags),
+    referenceImages: await loadReferences(flags)
+  };
+  await runImageRequest(request, void 0, providers);
+}
+async function resolveProviders(requested) {
+  try {
+    return await registry().resolve(requested);
+  } catch (error) {
+    fail("usage", error instanceof Error ? error.message : String(error), EXIT_USAGE);
+  }
+}
+async function runEdit(flags) {
+  const prompt = flagValue(flags, "prompt");
+  const out = flagValue(flags, "out");
+  const source = flagValue(flags, "source");
+  const mask = flagValue(flags, "mask");
+  if (!prompt) fail("usage", "Missing required --prompt.", EXIT_USAGE);
+  if (!out) fail("usage", "Missing required --out.", EXIT_USAGE);
+  if (!source) fail("usage", "Missing required --source.", EXIT_USAGE);
+  const request = {
+    prompt,
+    out,
+    size: flagValue(flags, "size"),
+    quality: flagValue(flags, "quality"),
+    format: flagValue(flags, "format"),
+    count: parseCount(flags),
+    referenceImages: await loadReferences(flags),
+    sourceImage: await loadImageInput(source, "Source image"),
+    mask: mask ? await loadImageInput(mask, "Mask image") : void 0
+  };
+  await runImageRequest(request, request, await resolveProviders(requestedProviders(flags)));
+}
+async function runImageRequest(request, edit, providers) {
+  const multiProvider = providers.length > 1;
+  for (const entry of providers) {
+    let result;
+    try {
+      result = edit ? await entry.provider.edit(edit) : await entry.provider.generate(request);
+    } catch (error) {
+      if (error instanceof ReauthRequiredError) fail("auth", `${entry.provider.name}: ${error.message}`, EXIT_AUTH);
+      if (error instanceof ProviderError) {
+        if (error.kind === "configuration" || error.kind === "usage") fail(error.kind, `${entry.provider.name}: ${error.message}`, EXIT_USAGE);
+        fail("provider", `${entry.provider.name}: ${error.kind}: ${error.message}`, EXIT_PROVIDER);
+      }
+      throw error;
+    }
+    const paths = await resolveOutPaths(request.out, entry.provider.name, multiProvider, result.images.length, request.format ?? "png");
+    await saveImages(result, paths);
+    printResult(entry.provider.name, result, paths);
+  }
+}
+async function main() {
+  const { flags, positionals } = parseArgs(process.argv.slice(2));
+  if (flags.get("help") || positionals.length === 0) {
+    process.stdout.write(helpFor(positionals[0]));
+    return;
+  }
+  const [command, sub, subSub] = positionals;
+  try {
+    if (command === "help") {
+      process.stdout.write(helpFor(sub));
+      return;
+    }
+    if (command === "providers" && !sub) {
+      await runProviders();
+      return;
+    }
+    if (command === "auth" && sub && !subSub) {
+      fail("usage", `Missing auth action. Usage: imagegen auth ${sub} login|status|logout.`, EXIT_USAGE);
+    }
+    if (command === "auth" && sub) {
+      if (subSub === "login") {
+        await runAuthLogin(sub, flags);
+        return;
+      }
+      if (subSub === "status") {
+        await runAuthStatus(sub, flags);
+        return;
+      }
+      if (subSub === "logout") {
+        await runAuthLogout(sub);
+        return;
+      }
+    }
+    if (command === "generate" && !sub) {
+      await runGenerate(flags);
+      return;
+    }
+    if (command === "edit" && !sub) {
+      await runEdit(flags);
+      return;
+    }
+    fail("usage", `Unknown command: ${positionals.join(" ")}. Run \`imagegen help\`.`, EXIT_USAGE);
+  } catch (error) {
+    if (error instanceof ProviderError) fail("provider", `${error.kind}: ${error.message}`, EXIT_PROVIDER);
+    fail("provider", error instanceof Error ? error.message : String(error), EXIT_PROVIDER);
+  }
+}
+await main();
+//# sourceMappingURL=index.mjs.map