@dorely13/ai-imagegen-cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { mkdir as mkdir3, readFile as readFile3, stat, writeFile as writeFile3 } from "node:fs/promises";
-import { basename, dirname as dirname3, extname, join as join4, resolve as resolve2 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile3, 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
 var ProviderError = class extends Error {
@@ -226,20 +226,24 @@ 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 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_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";
+var TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+var TOKEN_REQUEST_TIMEOUT_MS = 30 * 1e3;
+var REFRESH_LOCK_FILE = "codex-refresh.lock";
+var REFRESH_LOCK_STALE_MS = 60 * 1e3;
+var REFRESH_LOCK_WAIT_MS = 90 * 1e3;
+var REFRESH_LOCK_POLL_MS = 100;
 
 // ../../packages/providers-codex/dist/pkce.js
 import { createHash, randomBytes } from "node:crypto";
@@ -282,7 +286,7 @@ 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((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let server;
     const timer = setTimeout(() => {
       closeServer();
@@ -322,7 +326,7 @@ async function waitForOAuthCallback(timeoutMs = FLOW_TIMEOUT_MINUTES * 60 * 1e3,
         res.writeHead(200, { "content-type": "text/html" });
         res.end(callbackPage("Connected", "ImageGenCli is connected. You can close this tab."));
         closeServer();
-        resolve3({ code, state });
+        resolve4({ code, state });
       } catch (error2) {
         fail2(error2 instanceof Error ? error2 : new LoopbackError("OAuth callback failed.", "callback_error"));
       }
@@ -340,7 +344,7 @@ async function waitForOAuthCallback(timeoutMs = FLOW_TIMEOUT_MINUTES * 60 * 1e3,
 
 // ../../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.") {
+  constructor(message = "Codex credentials are missing or expired. Run `imagegen auth codex login` to reconnect.") {
     super(message);
     this.name = "ReauthRequiredError";
   }
@@ -353,10 +357,24 @@ function toTokenSet(body, fallbackRefreshToken) {
     scope: body.scope
   };
 }
+var REJECTED_GRANT_CODES = /* @__PURE__ */ new Set([
+  "invalid_grant",
+  "invalid_token",
+  "refresh_token_expired",
+  "refresh_token_reused",
+  "refresh_token_invalidated"
+]);
 async function readOAuthErrorCode(response) {
   try {
     const body = await response.json();
-    return typeof body.error === "string" ? body.error : null;
+    if (typeof body.error === "string")
+      return body.error;
+    if (typeof body.error === "object" && body.error !== null) {
+      const code = body.error["code"];
+      if (typeof code === "string")
+        return code;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -365,30 +383,31 @@ async function postTokenRequest(params) {
   const response = await fetch(TOKEN_ENDPOINT, {
     method: "POST",
     headers: { "content-type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams(params)
+    body: new URLSearchParams(params),
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
   });
   if (!response.ok) {
     const errorCode = await readOAuthErrorCode(response.clone());
-    if (response.status === 401 || response.status === 400 && (errorCode === "invalid_grant" || errorCode === "invalid_token")) {
-      return null;
+    if (response.status === 401 || errorCode !== null && REJECTED_GRANT_CODES.has(errorCode)) {
+      return { ok: false, reason: errorCode ?? `status ${response.status}` };
     }
-    throw new Error(`Token request failed with status ${response.status}.`);
+    throw new Error(`Token request failed with status ${response.status}${errorCode ? ` (${errorCode})` : ""}.`);
   }
   const body = await response.json();
-  return toTokenSet(body, params["refresh_token"]);
+  return { ok: true, tokens: toTokenSet(body, params["refresh_token"]) };
 }
 async function exchangeCodeForTokens(args) {
-  const tokens = await postTokenRequest({
+  const outcome = 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.");
+  if (!outcome.ok) {
+    throw new ReauthRequiredError(`The authorization code was rejected (${outcome.reason}). Run \`imagegen auth codex login\` again.`);
   }
-  return tokens;
+  return outcome.tokens;
 }
 async function refreshTokens(refreshToken) {
   return postTokenRequest({
@@ -397,8 +416,8 @@ async function refreshTokens(refreshToken) {
     refresh_token: refreshToken
   });
 }
-function isTokenExpired(tokens, now = Date.now()) {
-  return tokens.expiresAt <= now;
+function needsRefresh(tokens, now = Date.now()) {
+  return tokens.expiresAt - TOKEN_REFRESH_MARGIN_MS <= now;
 }
 var pendingVerifiers = /* @__PURE__ */ new Map();
 function startPkceFlow(redirectUri2) {
@@ -424,65 +443,9 @@ function prunePendingVerifiers() {
   }
 }
 
-// ../../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/refresh-lock.js
+import { mkdir, open, rm, stat } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
 
 // ../../packages/credentials/dist/index.js
 import { homedir } from "node:os";
@@ -490,8 +453,8 @@ import { join } from "node:path";
 function asKeytar(module) {
   if (typeof module !== "object" || module === null)
     return null;
-  const record2 = module;
-  const candidate = record2["default"] ?? module;
+  const record3 = module;
+  const candidate = record3["default"] ?? module;
   if (typeof candidate.getPassword === "function" && typeof candidate.setPassword === "function" && typeof candidate.deletePassword === "function") {
     return candidate;
   }
@@ -582,9 +545,9 @@ var FileCredentialStore = class {
     }
   }
   async writeAll(all) {
-    const { mkdir: mkdir4, writeFile: writeFile4, chmod } = await import("node:fs/promises");
-    const { dirname: dirname4 } = await import("node:path");
-    await mkdir4(dirname4(this.filePath), { recursive: true });
+    const { mkdir: mkdir6, writeFile: writeFile4, chmod } = await import("node:fs/promises");
+    const { dirname: dirname6 } = await import("node:path");
+    await mkdir6(dirname6(this.filePath), { recursive: true });
     await writeFile4(this.filePath, JSON.stringify(all, null, 2), {
       mode: 384
     });
@@ -602,6 +565,133 @@ function defaultCredentialFilePath() {
   return join(base, "ImageGenCli", "tokens.json");
 }
 
+// ../../packages/providers-codex/dist/refresh-lock.js
+function defaultRefreshLockPath() {
+  return join2(dirname(defaultCredentialFilePath()), REFRESH_LOCK_FILE);
+}
+function createRefreshLock(options = {}) {
+  const path = options.path ?? defaultRefreshLockPath();
+  const staleMs = options.staleMs ?? REFRESH_LOCK_STALE_MS;
+  const waitMs = options.waitMs ?? REFRESH_LOCK_WAIT_MS;
+  const pollMs = options.pollMs ?? REFRESH_LOCK_POLL_MS;
+  return async (work) => {
+    await acquire(path, staleMs, waitMs, pollMs);
+    try {
+      return await work();
+    } finally {
+      await rm(path, { force: true });
+    }
+  };
+}
+async function acquire(path, staleMs, waitMs, pollMs) {
+  await mkdir(dirname(path), { recursive: true });
+  const deadline = Date.now() + waitMs;
+  for (; ; ) {
+    try {
+      const handle = await open(path, "wx");
+      try {
+        await handle.writeFile(`${process.pid}
+`);
+      } finally {
+        await handle.close();
+      }
+      return;
+    } catch (error2) {
+      if (!isContention(error2))
+        throw error2;
+    }
+    if (await isStale(path, staleMs)) {
+      await rm(path, { force: true });
+      continue;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error("Timed out waiting for another imagegen process to refresh Codex credentials.");
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, pollMs + Math.random() * pollMs));
+  }
+}
+function isContention(error2) {
+  const code = error2.code;
+  return code === "EEXIST" || process.platform === "win32" && (code === "EPERM" || code === "EACCES");
+}
+async function isStale(path, staleMs) {
+  try {
+    return Date.now() - (await stat(path)).mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+
+// ../../packages/providers-codex/dist/codex-token-manager.js
+var CodexTokenManager = class {
+  store;
+  pendingRefresh = null;
+  lock;
+  refresh;
+  constructor(store, options = {}) {
+    this.store = store;
+    this.lock = options.lock ?? createRefreshLock();
+    this.refresh = options.refresh ?? refreshTokens;
+  }
+  async exchangeAndSave(args) {
+    const tokens = await exchangeCodeForTokens(args);
+    await this.store.save(PROVIDER_NAME, tokens);
+    return tokens;
+  }
+  async status() {
+    if (!await this.store.load(PROVIDER_NAME))
+      return { connected: false };
+    try {
+      await this.getValidAccessToken();
+      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 (!needsRefresh(tokens))
+      return tokens.accessToken;
+    return this.refreshFrom(tokens.accessToken);
+  }
+  // The Codex image endpoint rejected this access token before its recorded expiry.
+  async recoverFromUnauthorized(rejectedAccessToken) {
+    return this.refreshFrom(rejectedAccessToken);
+  }
+  refreshFrom(staleAccessToken) {
+    if (!this.pendingRefresh) {
+      this.pendingRefresh = this.lock(() => this.refreshLocked(staleAccessToken)).finally(() => {
+        this.pendingRefresh = null;
+      });
+    }
+    return this.pendingRefresh;
+  }
+  async refreshLocked(staleAccessToken) {
+    const current = await this.store.load(PROVIDER_NAME);
+    if (!current)
+      throw new ReauthRequiredError();
+    if (current.accessToken !== staleAccessToken && !needsRefresh(current))
+      return current.accessToken;
+    if (!current.refreshToken) {
+      await this.store.clear(PROVIDER_NAME);
+      throw new ReauthRequiredError();
+    }
+    const outcome = await this.refresh(current.refreshToken);
+    if (!outcome.ok) {
+      await this.store.clear(PROVIDER_NAME);
+      throw new ReauthRequiredError(`Codex rejected the stored refresh token (${outcome.reason}). Run \`imagegen auth codex login\` to reconnect.`);
+    }
+    await this.store.save(PROVIDER_NAME, outcome.tokens);
+    return outcome.tokens.accessToken;
+  }
+};
+
 // ../../packages/providers-codex/dist/token-store.js
 async function resolveTokenStore() {
   const store = await resolveCredentialStore();
@@ -642,13 +732,18 @@ function extractAccountId(token) {
   return accountId;
 }
 
-// ../../packages/providers-codex/dist/sse.js
+// ../../packages/providers-codex/dist/codex-client.js
+import sharp from "sharp";
+
+// ../../packages/providers-codex/dist/errors.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 (/usage limit/i.test(message))
+    return "usage_limit";
   if (/rate limit|429|too many requests|please try again/i.test(message))
     return "rate_limit";
   if (/403|forbidden|cloudflare/i.test(message))
@@ -657,107 +752,26 @@ function classifyImageError(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 record2 = event;
-  const nested = record2["error"];
-  if (typeof nested === "object" && nested !== null) {
-    const message = readString(nested, "message");
-    if (message)
-      return message;
-  }
-  const response = record2["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)
+function readErrorMessage(body) {
+  if (!body.trim())
     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);
-          }
-        }
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null) {
+      const record3 = parsed;
+      if (typeof record3["message"] === "string")
+        return record3["message"];
+      if (typeof record3["detail"] === "string")
+        return record3["detail"];
+      const error2 = record3["error"];
+      if (typeof error2 === "object" && error2 !== null && typeof error2["message"] === "string") {
+        return error2["message"];
       }
     }
+  } catch {
+    return body.slice(0, 500);
   }
-  throw new Error(`stream_completed_without_image: Codex image generation completed without returning an image. responseId=${responseId ?? "unknown"}, events=${eventCount}, lastEvent=${lastEventType ?? "none"}.`);
+  return null;
 }
 
 // ../../packages/providers-codex/dist/codex-client.js
@@ -779,112 +793,39 @@ function resolveSize(size) {
     });
   }
 }
-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 {
+function buildBody(args) {
+  const body = {
+    prompt: args.prompt,
     model: args.model,
-    input: [{ role: "user", content }],
-    tools: [args.tool],
-    tool_choice: { type: "image_generation" },
-    stream: true,
-    store: false
+    size: args.size.size,
+    background: "auto"
   };
+  const quality = args.quality.trim();
+  if (quality && quality.toLowerCase() !== "auto")
+    body["quality"] = quality;
+  if (args.images.length > 0)
+    body["images"] = args.images.map((image) => ({ image_url: toDataUrl(image) }));
+  return body;
 }
 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);
-    const imageModel2 = this.resolveImageModel(request);
-    return this.runAll({
-      format,
-      imageModel: imageModel2,
-      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: imageModel2,
-          action: "generate",
-          partialImages: this.partialImages
-        })
-      })
-    });
+    const references = (request.referenceImages ?? []).slice(0, MAX_REFERENCE_IMAGES2);
+    return this.runAll(request, references.length > 0 ? "edits" : "generations", references);
   }
   async edit(request) {
-    const format = normalizeOutputFormat(request.format);
-    const size = this.sizePolicy.resolveSize(request.size);
-    const imageModel2 = this.resolveImageModel(request);
-    const references = [request.sourceImage, ...request.referenceImages ?? []];
-    return this.runAll({
-      format,
-      imageModel: imageModel2,
-      count: normalizeCount(request.count),
-      prompt: request.prompt,
-      size,
-      build: () => {
-        const tool = baseImageTool({
-          size: size.size,
-          quality: request.quality ?? DEFAULT_QUALITY,
-          outputFormat: format,
-          imageModel: imageModel2,
-          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
-        });
-      }
-    });
+    return this.runAll(request, "edits", [request.sourceImage, ...request.referenceImages ?? []].slice(0, MAX_REFERENCE_IMAGES2));
   }
   resolveImageModel(request) {
     const model = (request.model ?? this.imageModel).trim();
@@ -896,116 +837,120 @@ var CodexImageProvider = class {
     }
     return model;
   }
-  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));
+  async runAll(request, endpoint, images) {
+    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 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 };
+  }
+  async sendOnce(endpoint, body, format, prompt) {
+    let accessToken = await this.tokens.getValidAccessToken();
+    let response = await this.post(endpoint, accessToken, body);
+    if (response.status === 401) {
+      await response.body?.cancel();
+      accessToken = await this.tokens.recoverFromUnauthorized(accessToken);
+      response = await this.post(endpoint, accessToken, body);
+    }
+    const requestId = response.headers.get("x-codex-imagegen-request-id") ?? response.headers.get("x-oai-request-id") ?? response.headers.get("x-request-id") ?? void 0;
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      const kind = classifyImageError(errorText);
+      const detail = readErrorMessage(errorText);
+      const retryAfter = Number(response.headers.get("retry-after"));
+      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,
+        ...Number.isFinite(retryAfter) && retryAfter > 0 ? { retryAfterSeconds: retryAfter } : {}
+      });
+    }
+    const payload = record(await response.json().catch(() => null));
+    const item = Array.isArray(payload["data"]) ? record(payload["data"][0]) : {};
+    if (typeof item["b64_json"] !== "string" || !item["b64_json"]) {
+      throw new ProviderError({ kind: "no_image", message: "Codex image request returned no image data.", requestId });
+    }
+    let data = Buffer.from(item["b64_json"], "base64");
+    let width;
+    let height;
+    try {
+      const metadata = await sharp(data).metadata();
+      if (!metadata.width || !metadata.height || !["png", "jpeg", "webp"].includes(metadata.format ?? ""))
+        throw new Error();
+      await sharp(data).stats();
+      if (metadata.format !== format)
+        data = await sharp(data).toFormat(format).toBuffer();
+      width = metadata.width;
+      height = metadata.height;
+    } catch {
+      throw new ProviderError({ kind: "malformed", message: "Codex returned an invalid raster image.", requestId });
     }
-    return { provider: this.name, imageModel: args.imageModel, images };
+    return {
+      data,
+      mimeType: `image/${format}`,
+      width,
+      height,
+      prompt,
+      responseId: typeof item["generation_id"] === "string" ? item["generation_id"] : void 0,
+      usage: {
+        requestId,
+        imageGeneration: payload["usage"],
+        // What the backend actually rendered; it may override requested size and quality.
+        served: { size: payload["size"], quality: payload["quality"], background: payload["background"] },
+        planLimits: readPlanLimits(response.headers)
+      }
+    };
   }
-  async sendOnce(payload, format, prompt, size) {
-    const accessToken = await this.tokens.getValidAccessToken();
-    const accountId = extractAccountId(accessToken);
+  async post(endpoint, accessToken, body) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutSeconds * 1e3);
-    let response;
     try {
-      response = await this.fetchImpl(RESPONSES_ENDPOINT, {
+      return await this.fetchImpl(`${IMAGES_ENDPOINT}/${endpoint}`, {
         method: "POST",
         headers: {
           authorization: `Bearer ${accessToken}`,
-          "chatgpt-account-id": accountId,
-          "OpenAI-Beta": "responses=experimental",
+          "chatgpt-account-id": extractAccountId(accessToken),
           originator: "pi",
           "user-agent": USER_AGENT,
-          accept: "text/event-stream",
+          accept: "application/json",
           "content-type": "application/json"
         },
-        body: JSON.stringify(payload),
+        body,
         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 (error2) {
-      throw toProviderError(error2, 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 record2 = parsed;
-      if (typeof record2["message"] === "string")
-        return record2["message"];
-      if (typeof record2["detail"] === "string")
-        return record2["detail"];
-      const error2 = record2["error"];
-      if (typeof error2 === "object" && error2 !== null && typeof error2["message"] === "string") {
-        return error2["message"];
-      }
-    }
-  } catch {
-    return body.slice(0, 500);
-  }
-  return null;
-}
-function toProviderError(error2, requestId) {
-  const message = error2 instanceof Error ? error2.message : String(error2);
-  const separator = message.indexOf(":");
-  const kind = separator > 0 ? message.slice(0, separator) : "api_error";
-  return new ProviderError({ kind, message, requestId });
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function readPlanLimits(headers) {
+  const number = (name) => {
+    const value = headers.get(`x-codex-${name}`);
+    const parsed = value === null ? Number.NaN : Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  };
+  const window = (name) => {
+    const usedPercent = number(`${name}-used-percent`);
+    const windowMinutes = number(`${name}-window-minutes`);
+    if (usedPercent === void 0 || !windowMinutes)
+      return void 0;
+    return { usedPercent, windowMinutes, resetAt: number(`${name}-reset-at`) };
+  };
+  const limits = {
+    planType: headers.get("x-codex-plan-type") ?? void 0,
+    activeLimit: headers.get("x-codex-active-limit") ?? void 0,
+    primary: window("primary"),
+    secondary: window("secondary")
+  };
+  return Object.values(limits).some((value) => value !== void 0) ? limits : void 0;
 }
 
 // ../../packages/providers-codex/dist/codex-entry.js
@@ -1049,7 +994,7 @@ function createCodexEntry() {
 }
 
 // ../../packages/providers-google/dist/gemini-client.js
-import sharp from "sharp";
+import sharp2 from "sharp";
 
 // ../../packages/providers-google/dist/image-size.js
 var DEFAULT_IMAGE_MODEL2 = "gemini-nano-banana-2.1";
@@ -1244,12 +1189,12 @@ var GeminiImageProvider = class {
       if (typeof image.data !== "string" || !image.data || !/^[A-Za-z0-9+/]+={0,2}$/.test(image.data) || image.data.length % 4 !== 0)
         throw error("malformed", "Gemini returned invalid inline image data.");
       const original = Buffer.from(image.data, "base64");
-      const metadata = await sharp(original).metadata().catch(() => {
+      const metadata = await sharp2(original).metadata().catch(() => {
         throw error("malformed", "Gemini returned undecodable image bytes.");
       });
       if (!metadata.width || !metadata.height || !["png", "jpeg", "webp"].includes(metadata.format ?? "") || image.mime_type !== `image/${metadata.format}`)
         throw error("malformed", "Gemini returned an invalid image or inconsistent MIME type.");
-      const data = metadata.format === format ? original : await sharp(original).toFormat(format).toBuffer();
+      const data = metadata.format === format ? original : await sharp2(original).toFormat(format).toBuffer();
       return {
         data,
         mimeType: `image/${format}`,
@@ -1315,8 +1260,8 @@ function createGeminiEntry() {
 }
 
 // ../../packages/providers-configurable/dist/profiles.js
-import { readFile, mkdir, writeFile, rename, rm } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
+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 { randomUUID } from "node:crypto";
 var usage = (message) => new ProviderError({ kind: "usage", message });
 var profileStore = () => resolveCredentialStore();
@@ -1366,7 +1311,7 @@ function validateProfile(value) {
 var ProfileRepository = class {
   path;
   credentials;
-  constructor(path = join2(dirname(defaultCredentialFilePath()), "providers.json"), credentials = profileStore) {
+  constructor(path = join3(dirname2(defaultCredentialFilePath()), "providers.json"), credentials = profileStore) {
     this.path = path;
     this.credentials = credentials;
   }
@@ -1431,7 +1376,7 @@ var ProfileRepository = class {
   async save(profiles) {
     const temporary = `${this.path}.${randomUUID()}.tmp`;
     try {
-      await mkdir(dirname(this.path), { recursive: true });
+      await mkdir2(dirname2(this.path), { recursive: true });
       await writeFile(temporary, JSON.stringify({ version: 1, profiles }, null, 2) + "\n", { mode: 384 });
       await rename(temporary, this.path);
     } catch {
@@ -1440,7 +1385,7 @@ var ProfileRepository = class {
         message: "Could not save endpoint configuration."
       });
     } finally {
-      await rm(temporary, { force: true }).catch(() => {
+      await rm2(temporary, { force: true }).catch(() => {
       });
     }
   }
@@ -1449,9 +1394,9 @@ async function profileKey(profile, store) {
   if (profile.auth === "none")
     return void 0;
   try {
-    const record2 = await store.load(profile.name);
-    if (record2 && typeof record2.apiKey === "string")
-      return validateApiKey(record2.apiKey);
+    const record3 = await store.load(profile.name);
+    if (record3 && typeof record3.apiKey === "string")
+      return validateApiKey(record3.apiKey);
   } catch {
   }
   throw new ProviderError({
@@ -1461,7 +1406,7 @@ async function profileKey(profile, store) {
 }
 
 // ../../packages/providers-configurable/dist/provider.js
-import sharp2 from "sharp";
+import sharp3 from "sharp";
 
 // ../../packages/providers-configurable/dist/image-size.js
 function imageSize(value, api) {
@@ -1487,7 +1432,7 @@ function imageSize(value, api) {
 }
 
 // ../../packages/providers-configurable/dist/http.js
-var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var EndpointHttp = class {
   fetchImpl;
   timeoutSeconds;
@@ -1511,9 +1456,9 @@ var EndpointHttp = class {
       });
       if (!response.ok) {
         const status = response.status;
-        const failure2 = record(await response.json().catch(() => null));
-        const detail = record(failure2.error);
-        const upstream = record(detail.metadata).provider_name;
+        const failure2 = record2(await response.json().catch(() => null));
+        const detail = record2(failure2.error);
+        const upstream = record2(detail.metadata).provider_name;
         const token = new Headers(init.headers).get("authorization")?.replace(/^Bearer\s+/i, "");
         const upstreamProvider = typeof upstream === "string" && /^[A-Za-z0-9][A-Za-z0-9 ._()-]{0,63}$/.test(upstream) && !(token && upstream.includes(token)) && !/(?:sk-|AIza)/.test(upstream) ? upstream : void 0;
         const retryHeader = response.headers.get("retry-after");
@@ -1537,7 +1482,7 @@ var EndpointHttp = class {
             const value = await response.json();
             if (!value || typeof value !== "object" || Array.isArray(value))
               throw new Error();
-            return record(value);
+            return record2(value);
           } catch {
             throw new ProviderError({
               kind: "malformed",
@@ -1672,14 +1617,14 @@ var ConfigurableImageProvider = class {
           message: "Model discovery response must contain a data array."
         });
       return body.data.map((value) => {
-        const model = record(value);
+        const model = record2(value);
         if (typeof model.id !== "string")
           throw new ProviderError({
             kind: "malformed",
             message: "Discovered model has no string ID."
           });
-        const architecture = record(model.architecture);
-        const supported = record(model.supported_parameters);
+        const architecture = record2(model.architecture);
+        const supported = record2(model.supported_parameters);
         const strings = (v) => Array.isArray(v) && v.every((s) => typeof s === "string") ? v : void 0;
         return {
           id: model.id,
@@ -1737,7 +1682,7 @@ var ConfigurableImageProvider = class {
             kind: "malformed",
             message: "Endpoint must return exactly one image for a single-image request."
           });
-        const image = record(body.data[0]);
+        const image = record2(body.data[0]);
         let data;
         if (typeof image.b64_json === "string") {
           if (!image.b64_json || image.b64_json.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(image.b64_json))
@@ -1768,12 +1713,12 @@ var ConfigurableImageProvider = class {
             message: "Endpoint returned no image bytes or download URL."
           });
         try {
-          const metadata = await sharp2(data).metadata();
+          const metadata = await sharp3(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 sharp2(data).stats();
+          await sharp3(data).stats();
           if (metadata.format !== format)
-            data = await sharp2(data).toFormat(format).toBuffer();
+            data = await sharp3(data).toFormat(format).toBuffer();
           return {
             data,
             width: metadata.width,
@@ -1833,7 +1778,7 @@ async function readApiKey(fromStdin, input = process.stdin, output = process.std
   const wasRaw = terminal.isRaw;
   const wasFlowing = input.readableFlowing === true;
   emitKeypressEvents(input);
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let text = "";
     const cleanup = () => {
       input.removeListener("keypress", onKey);
@@ -1858,7 +1803,7 @@ async function readApiKey(fromStdin, input = process.stdin, output = process.std
       }
       if (key.name === "return" || key.name === "enter") {
         cleanup();
-        resolve3(text);
+        resolve4(text);
         return;
       }
       if (key.name === "backspace") {
@@ -1908,7 +1853,7 @@ Supported protocols: OpenRouter dedicated Images API and OpenAI Images JSON /
 multipart endpoints, 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 or Codex.
+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.
 `;
@@ -1946,7 +1891,9 @@ Supported Codex models (account availability is determined by the provider):
 Use full model IDs; other provider-supported IDs may also be supplied.
 Model precedence: --model > constructor imageModel (library callers) >
 IMAGEGEN_CODEX_IMAGE_MODEL > gpt-image-2.5-flare.
-IMAGEGEN_CODEX_MODEL configures orchestration separately; --model selects images.
+Codex may override the requested model, quality, and size; results report the
+returned dimensions. Codex ignores --mask; describe the region in the prompt.
+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.
@@ -1959,7 +1906,7 @@ var GENERATE_EXAMPLES = `Examples:
 `;
 var EDIT_EXAMPLES = `Edit options:
   --source <file>        Source image (required)
-  --mask <file>          Optional edit mask (Codex or openai-images)
+  --mask <file>          Optional edit mask (openai-images; Codex ignores it)
 
 Examples:
   imagegen edit --format webp --source ./product.png --prompt "make the product blue" --out ./blue.webp
@@ -2102,9 +2049,9 @@ ${USAGE}`;
 }
 
 // src/skill.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3, resolve } from "node:path";
+import { dirname as dirname3, join as join4, resolve } from "node:path";
 var SKILL_NAME = "imagegen-cli";
 var SkillExistsError = class extends Error {
   constructor(path) {
@@ -2116,8 +2063,8 @@ async function skillText() {
   return readFile2(new URL("../skill/SKILL.md", import.meta.url), "utf8");
 }
 function targetPath(target) {
-  const root = target === "claude" ? join3(homedir2(), ".claude", "skills") : target === "codex" ? join3(homedir2(), ".agents", "skills") : resolve(target);
-  return join3(root, SKILL_NAME, "SKILL.md");
+  const root = target === "claude" ? join4(homedir2(), ".claude", "skills") : target === "codex" ? join4(homedir2(), ".agents", "skills") : resolve(target);
+  return join4(root, SKILL_NAME, "SKILL.md");
 }
 async function existingText(path) {
   try {
@@ -2143,12 +2090,50 @@ async function installSkill(targets, force) {
   }
   for (const item of planned.values()) {
     if (item.status === "up-to-date") continue;
-    await mkdir2(dirname2(item.path), { recursive: true });
+    await mkdir3(dirname3(item.path), { recursive: true });
     await writeFile2(item.path, content, { encoding: "utf8", flag: item.status === "installed" ? "wx" : "w" });
   }
   return [...planned.values()];
 }
 
+// src/usage-log.ts
+import { appendFile, mkdir as mkdir4 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve2 } from "node:path";
+var USAGE_LOG_ENV = "IMAGEGEN_USAGE_LOG";
+function usageLogEntry(request, edit, result, paths) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    command: edit ? "edit" : "generate",
+    provider: result.provider,
+    imageModel: result.imageModel,
+    requested: {
+      size: request.size ?? "auto",
+      quality: request.quality ?? "auto",
+      format: request.format ?? "png",
+      count: request.count ?? 1,
+      references: request.referenceImages?.length ?? 0,
+      mask: edit ? edit.mask !== void 0 : void 0
+    },
+    images: result.images.map((image, i) => ({
+      path: paths[i],
+      width: image.width,
+      height: image.height,
+      bytes: image.data.byteLength,
+      responseId: image.responseId,
+      usage: image.usage
+    }))
+  };
+}
+async function appendUsageLog(entry) {
+  const target = process.env[USAGE_LOG_ENV]?.trim();
+  if (!target) return void 0;
+  const path = resolve2(target);
+  await mkdir4(dirname4(path), { recursive: true });
+  await appendFile(path, `${JSON.stringify(entry)}
+`, "utf8");
+  return path;
+}
+
 // src/index.ts
 var EXIT_USAGE = 2;
 var EXIT_AUTH = 3;
@@ -2277,10 +2262,10 @@ function requestedProviders(flags) {
   return raw;
 }
 async function resolveOutPaths(out, providerName, multiProvider, count, format) {
-  const resolved = resolve2(out);
+  const resolved = resolve3(out);
   let isDir = false;
   try {
-    const info = await stat(resolved);
+    const info = await stat2(resolved);
     isDir = info.isDirectory();
   } catch {
     isDir = extname(resolved) === "";
@@ -2288,12 +2273,12 @@ async function resolveOutPaths(out, providerName, multiProvider, count, format)
   const extension = `.${normalizeOutputFormat(format)}`;
   const prefix = multiProvider ? `${providerName}-` : "";
   if (isDir) {
-    return Array.from({ length: count }, (_, i) => join4(resolved, `${prefix}image-${i + 1}${extension}`));
+    return Array.from({ length: count }, (_, i) => join5(resolved, `${prefix}image-${i + 1}${extension}`));
   }
   if (count > 1 || multiProvider) {
-    const dir = dirname3(resolved);
+    const dir = dirname5(resolved);
     const base = basename(resolved, extname(resolved));
-    return Array.from({ length: count }, (_, i) => join4(dir, `${prefix}${base}-${i + 1}${extension}`));
+    return Array.from({ length: count }, (_, i) => join5(dir, `${prefix}${base}-${i + 1}${extension}`));
   }
   return [resolved.endsWith(extension) ? resolved : `${resolved}${extension}`];
 }
@@ -2318,7 +2303,7 @@ async function saveImages(result, paths) {
   for (let i = 0; i < result.images.length; i += 1) {
     const path = paths[i];
     try {
-      await mkdir3(dirname3(path), { recursive: true });
+      await mkdir5(dirname5(path), { recursive: true });
       await writeFile3(path, Buffer.from(result.images[i].data));
     } catch {
       fail("io", `Could not write output file: ${path}`, EXIT_IO);
@@ -2391,8 +2376,8 @@ async function runAuthLogin(providerName, flags) {
   const waiter = waitForOAuthCallback(timeoutMinutes * 60 * 1e3, port);
   if (!flags.get("no-open")) {
     try {
-      const { default: open } = await import("open");
-      await open(url);
+      const { default: open2 } = await import("open");
+      await open2(url);
     } catch {
       process.stderr.write("Could not open a browser automatically. Open this URL manually:\n");
     }
@@ -2525,6 +2510,12 @@ async function runImageRequest(request, edit, providers) {
     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);
+    try {
+      await appendUsageLog(usageLogEntry(request, edit, result, paths));
+    } catch {
+      process.stderr.write(`${JSON.stringify({ warning: { kind: "io", message: `Could not append to ${USAGE_LOG_ENV} file.` } })}
+`);
+    }
   }
 }
 async function main() {