codex-copilot-dx 0.4.25 → 0.4.27

package/src/image-optimization.mjs

@@ -0,0 +1,151 @@
+import { status } from "./status.mjs";
+
+const IMG_MAX_DIM = Number.parseInt(process.env.CCDX_IMG_MAX_DIM || "2048", 10);
+const IMG_QUALITY = Number.parseInt(process.env.CCDX_IMG_QUALITY || "85", 10);
+const IMG_MIN_BYTES = Number.parseInt(process.env.CCDX_IMG_MIN_BYTES || "100000", 10);
+const DEFAULT_IMG_CONCURRENCY = 4;
+const IMG_MAX_CONCURRENCY = 12;
+const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
+const IMG_CONCURRENCY = parseImageConcurrency(process.env.CCDX_IMG_CONCURRENCY);
+let sharpImport = null;
+
+export function parseImageConcurrency(value) {
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? Math.min(n, IMG_MAX_CONCURRENCY) : DEFAULT_IMG_CONCURRENCY;
+}
+
+async function sharp() {
+  sharpImport ||= import("sharp");
+  const mod = await sharpImport;
+  return mod.default || mod;
+}
+
+export async function optimizeImageDataUrl(dataUrl) {
+  if (IMG_OPT_DISABLED) return dataUrl;
+  if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:")) return dataUrl;
+  const match = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
+  if (!match) return dataUrl;
+  const mime = match[1].toLowerCase();
+  const raw = Buffer.from(match[2], "base64");
+  if (raw.length < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
+
+  try {
+    const resize = await sharp();
+    const out = await resize(raw, { failOn: "none" })
+      .rotate()
+      .resize(IMG_MAX_DIM, IMG_MAX_DIM, { fit: "inside", withoutEnlargement: true })
+      .webp({ quality: IMG_QUALITY, effort: 4 })
+      .toBuffer();
+    const ratio = ((out.length / raw.length) * 100).toFixed(1);
+    console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
+    return `data:image/webp;base64,${out.toString("base64")}`;
+  } catch (e) {
+    console.warn(status("warn", `image optimize failed (${mime}, ${raw.length}b): ${e.message}`));
+    return dataUrl;
+  }
+}
+
+export async function runWithConcurrency(taskFns, concurrency) {
+  if (!Array.isArray(taskFns) || taskFns.length === 0) return;
+  const limit = Math.min(parseImageConcurrency(concurrency), taskFns.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: limit }, async () => {
+    while (next < taskFns.length) {
+      const task = taskFns[next++];
+      await task();
+    }
+  }));
+}
+
+function visitImageParts(parts, tasks) {
+  if (!Array.isArray(parts)) return;
+  for (const part of parts) {
+    if (!part) continue;
+    if (part.type === "input_image" && typeof part.image_url === "string") {
+      tasks.push(async () => { part.image_url = await optimizeImageDataUrl(part.image_url); });
+    } else if (part.type === "image" && part.source?.type === "base64" && part.source?.data) {
+      tasks.push(async () => {
+        const dataUrl = `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
+        const optimized = await optimizeImageDataUrl(dataUrl);
+        const match = /^data:([^;]+);base64,(.+)$/.exec(optimized);
+        if (match) {
+          part.source.media_type = match[1];
+          part.source.data = match[2];
+        }
+      });
+    }
+  }
+}
+
+export async function optimizeImagesInBody(reqBody) {
+  if (IMG_OPT_DISABLED || !Array.isArray(reqBody.input)) return reqBody;
+  const tasks = [];
+
+  for (const item of reqBody.input) {
+    if (!item) continue;
+    if (item.type === "message" && Array.isArray(item.content)) {
+      visitImageParts(item.content, tasks);
+    }
+    if (item.type === "function_call_output") {
+      if (Array.isArray(item.output)) {
+        visitImageParts(item.output, tasks);
+      } else if (typeof item.output === "string") {
+        const trimmed = item.output.trim();
+        if (trimmed.startsWith("[")) {
+          try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+              const localTasks = [];
+              visitImageParts(parsed, localTasks);
+              if (localTasks.length) {
+                tasks.push(async () => {
+                  await runWithConcurrency(localTasks, IMG_CONCURRENCY);
+                  item.output = JSON.stringify(parsed);
+                });
+              }
+            }
+          } catch {
+            // Leave non-JSON tool output untouched.
+          }
+        }
+      }
+    }
+  }
+
+  if (tasks.length) await runWithConcurrency(tasks, IMG_CONCURRENCY);
+  return reqBody;
+}
+
+export function summarizeReqBody(reqBody) {
+  try {
+    const input = reqBody.input;
+    if (!Array.isArray(input)) return { items: 0, images: 0 };
+    let images = 0;
+    const countImages = (parts) => {
+      if (!Array.isArray(parts)) return;
+      for (const part of parts) {
+        if (part?.type === "input_image" || part?.type === "image") images += 1;
+      }
+    };
+
+    for (const item of input) {
+      if (item?.type === "message") countImages(item.content);
+      if (item?.type === "function_call_output") {
+        if (Array.isArray(item.output)) {
+          countImages(item.output);
+        } else if (typeof item.output === "string" && item.output.trim().startsWith("[")) {
+          try {
+            const parsed = JSON.parse(item.output);
+            if (Array.isArray(parsed)) countImages(parsed);
+          } catch {
+            // Ignore non-JSON tool output.
+          }
+        }
+      }
+    }
+
+    return { items: input.length, images };
+  } catch {
+    return { items: -1, images: -1 };
+  }
+}

package/src/log.mjs

@@ -3,8 +3,10 @@ import os from "node:os";
 import path from "node:path";
 import { format } from "node:util";
 import { status } from "./status.mjs";
+import { parseByteLimit, rotateFileIfNeededSync } from "./file-rotation.mjs";
 
 let globalInstall = null;
+const DEFAULT_LOG_MAX_BYTES = 16 * 1024 * 1024;
 
 export function normalizeLogLevel(value) {
   return String(value || "info").trim().toLowerCase() === "debug" ? "debug" : "info";
@@ -27,6 +29,10 @@ export function isDebugLoggingEnabled(env = process.env) {
   return normalizeLogLevel(env.CCDX_LOG_LEVEL) === "debug";
 }
 
+export function debugLogMaxBytes(env = process.env) {
+  return parseByteLimit(env.CCDX_LOG_MAX_BYTES, DEFAULT_LOG_MAX_BYTES);
+}
+
 function renderLogPayload(args) {
   const stamp = new Date().toISOString();
   const text = format(...args);
@@ -56,7 +62,9 @@ export function configureLogging({
 
   function append(args) {
     try {
-      fs.appendFileSync(filePath, renderLogPayload(args), { encoding: "utf8", mode: 0o600 });
+      const payload = renderLogPayload(args);
+      rotateFileIfNeededSync(filePath, Buffer.byteLength(payload), debugLogMaxBytes(env));
+      fs.appendFileSync(filePath, payload, { encoding: "utf8", mode: 0o600 });
     } catch (e) {
       if (writeFailed) return;
       writeFailed = true;

package/src/models.mjs

@@ -60,6 +60,9 @@ const DEFAULT_CLAUDE_MODEL_ALIAS_DEFS = [
   },
 ];
 
+export const CODEX_AUTO_REVIEW_MODEL = "codex-auto-review";
+export const DEFAULT_CODEX_AUTO_REVIEW_MODEL = "gpt-5.4-mini";
+
 function cleanList(value) {
   return String(value || "")
     .split(",")
@@ -209,6 +212,19 @@ export function resolveAnthropicModel(model, env = process.env, options = {}) {
   };
 }
 
+export function resolveOpenAIModel(model, env = process.env) {
+  const requestedModel = String(model || "");
+  if (requestedModel !== CODEX_AUTO_REVIEW_MODEL) {
+    return { requestedModel, upstreamModel: requestedModel };
+  }
+
+  const configuredModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
+  return {
+    requestedModel,
+    upstreamModel: configuredModel || DEFAULT_CODEX_AUTO_REVIEW_MODEL,
+  };
+}
+
 export function anthropicModelInfo(model) {
   return {
     id: model.id,

package/src/response-history.mjs

@@ -0,0 +1,195 @@
+import { httpError } from "./http-transport.mjs";
+
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
+const DEFAULT_MAX_ENTRIES = 4096;
+
+function positiveInt(value, fallback) {
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+function cloneJson(value) {
+  return value === undefined ? undefined : structuredClone(value);
+}
+
+function jsonStringByteLength(value) {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0x22 || code === 0x5c) {
+      bytes += 2;
+    } else if (code <= 0x1f) {
+      bytes += [0x08, 0x09, 0x0a, 0x0c, 0x0d].includes(code) ? 2 : 6;
+    } else if (code <= 0x7f) {
+      bytes += 1;
+    } else if (code <= 0x7ff) {
+      bytes += 2;
+    } else if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4;
+        index += 1;
+      } else {
+        bytes += 6;
+      }
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      bytes += 6;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+
+function jsonByteLength(value, seen = new Set()) {
+  if (value === null) return 4;
+  if (typeof value === "string") return jsonStringByteLength(value);
+  if (typeof value === "number") return Buffer.byteLength(JSON.stringify(value));
+  if (typeof value === "boolean") return value ? 4 : 5;
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new TypeError("Circular response history value");
+    seen.add(value);
+    let bytes = 2 + Math.max(0, value.length - 1);
+    for (const item of value) {
+      bytes += item === undefined || typeof item === "function" || typeof item === "symbol"
+        ? 4
+        : jsonByteLength(item, seen);
+    }
+    seen.delete(value);
+    return bytes;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) throw new TypeError("Circular response history value");
+    seen.add(value);
+    const entries = Object.entries(value)
+      .filter(([, item]) => item !== undefined && typeof item !== "function" && typeof item !== "symbol");
+    let bytes = 2 + Math.max(0, entries.length - 1);
+    for (const [key, item] of entries) bytes += jsonStringByteLength(key) + 1 + jsonByteLength(item, seen);
+    seen.delete(value);
+    return bytes;
+  }
+  return 4;
+}
+
+const histories = new Map();
+const childrenById = new Map();
+const evictedIds = new Set();
+let totalBytes = 0;
+let maxBytes = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_BYTES, DEFAULT_MAX_BYTES);
+let maxEntries = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_ENTRIES, DEFAULT_MAX_ENTRIES);
+
+function rememberEvictedId(id) {
+  evictedIds.add(id);
+  while (evictedIds.size > 256) evictedIds.delete(evictedIds.values().next().value);
+}
+
+function linkChild(parentId, id) {
+  if (!parentId) return;
+  let children = childrenById.get(parentId);
+  if (!children) {
+    children = new Set();
+    childrenById.set(parentId, children);
+  }
+  children.add(id);
+}
+
+function unlinkChild(parentId, id) {
+  if (!parentId) return;
+  const children = childrenById.get(parentId);
+  if (!children) return;
+  children.delete(id);
+  if (!children.size) childrenById.delete(parentId);
+}
+
+function removeSubtree(rootId) {
+  const pending = [rootId];
+  const removed = new Set();
+  while (pending.length) {
+    const id = pending.pop();
+    if (removed.has(id)) continue;
+    removed.add(id);
+    const children = childrenById.get(id);
+    if (children) pending.push(...children);
+  }
+  for (const id of removed) {
+    const entry = histories.get(id);
+    if (!entry) continue;
+    unlinkChild(entry.parentId, id);
+    childrenById.delete(id);
+    totalBytes -= entry.bytes;
+    histories.delete(id);
+    rememberEvictedId(id);
+  }
+}
+
+function enforceLimits() {
+  while (histories.size > maxEntries || totalBytes > maxBytes) {
+    const oldestId = histories.keys().next().value;
+    if (!oldestId) break;
+    removeSubtree(oldestId);
+  }
+}
+
+export function clearResponseHistoryForTests() {
+  histories.clear();
+  childrenById.clear();
+  evictedIds.clear();
+  totalBytes = 0;
+  maxBytes = DEFAULT_MAX_BYTES;
+  maxEntries = DEFAULT_MAX_ENTRIES;
+}
+
+export function configureResponseHistoryForTests({ maxBytes: nextMaxBytes, maxEntries: nextMaxEntries } = {}) {
+  if (nextMaxBytes !== undefined) maxBytes = positiveInt(nextMaxBytes, DEFAULT_MAX_BYTES);
+  if (nextMaxEntries !== undefined) maxEntries = positiveInt(nextMaxEntries, DEFAULT_MAX_ENTRIES);
+}
+
+export function responseHistoryStats() {
+  return { entries: histories.size, bytes: totalBytes, evicted: evictedIds.size };
+}
+
+export function materializeResponseHistory(responseId) {
+  const chain = [];
+  const seen = new Set();
+  let currentId = responseId;
+  while (currentId) {
+    if (seen.has(currentId)) throw httpError(`Cycle detected in local response history: ${currentId}`, 500);
+    seen.add(currentId);
+    const entry = histories.get(currentId);
+    if (!entry) {
+      const reason = evictedIds.has(currentId) ? " was evicted after reaching the local history limit" : " is not available";
+      throw httpError(`previous_response_id${reason}: ${currentId}`, 400);
+    }
+    chain.push(entry);
+    currentId = entry.parentId;
+  }
+  const items = [];
+  for (const entry of chain.reverse()) items.push(...entry.inputItems, ...entry.outputItems);
+  return cloneJson(items);
+}
+
+export function rememberResponseHistoryNode({ id, parentId, inputItems, outputItems, takeOwnership = false }) {
+  if (!id || !Array.isArray(inputItems)) return;
+  const bytes = jsonByteLength([inputItems, outputItems]);
+  if (bytes > maxBytes) {
+    if (histories.has(id)) removeSubtree(id);
+    rememberEvictedId(id);
+    return;
+  }
+  const entry = {
+    parentId: parentId || null,
+    inputItems: takeOwnership ? inputItems : cloneJson(inputItems),
+    outputItems: takeOwnership ? outputItems : cloneJson(outputItems),
+    bytes,
+  };
+  const existing = histories.get(id);
+  if (existing) {
+    totalBytes -= existing.bytes;
+    unlinkChild(existing.parentId, id);
+  }
+  histories.set(id, entry);
+  linkChild(entry.parentId, id);
+  totalBytes += entry.bytes;
+  evictedIds.delete(id);
+  enforceLimits();
+}

package/src/shutdown.mjs

@@ -0,0 +1,29 @@
+export async function closeHttpServer(server, { timeoutMs = 5000 } = {}) {
+  if (!server?.listening) return { forced: false };
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer;
+    const finish = (error, forced = false) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (error) reject(error);
+      else resolve({ forced });
+    };
+
+    timer = setTimeout(() => {
+      server.closeAllConnections?.();
+      finish(null, true);
+    }, timeoutMs);
+    timer.unref?.();
+
+    try {
+      server.close((error) => finish(error));
+      server.closeIdleConnections?.();
+    } catch (e) {
+      if (e?.code === "ERR_SERVER_NOT_RUNNING") finish(null);
+      else finish(e);
+    }
+  });
+}

package/src/startup.mjs

@@ -0,0 +1,19 @@
+export async function initializeModelRegistry({
+  loadCached,
+  currentModelDefs,
+  refresh,
+  onBackgroundError = () => {},
+}) {
+  if (!loadCached()) {
+    return { modelDefs: await refresh(), source: "live", backgroundRefresh: null };
+  }
+
+  const backgroundRefresh = Promise.resolve()
+    .then(refresh)
+    .catch(onBackgroundError);
+  return { modelDefs: currentModelDefs(), source: "cache", backgroundRefresh };
+}
+
+export function runInBackground(task, onError = () => {}) {
+  return Promise.resolve().then(task).catch(onError);
+}

package/src/stream.mjs

@@ -1,6 +1,6 @@
 // Yield fetch Response body lines while preserving SSE semantics for callers.
 // Strip CRLF tails and release the reader if iteration stops early.
-export async function* webStreamLines(response) {
+export async function* webStreamLines(response, { onChunk } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buf = "";
@@ -8,6 +8,7 @@ export async function* webStreamLines(response) {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
+      onChunk?.(value);
       buf += decoder.decode(value, { stream: true });
       const lines = buf.split("\n");
       buf = lines.pop();

package/src/usage.mjs

@@ -1,8 +1,11 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import readline from "node:readline";
+import { parseByteLimit, rotateFileIfNeededSync, rotatedFilePath } from "./file-rotation.mjs";
 
 const DEFAULT_USAGE_PATH = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "usage.jsonl");
+const DEFAULT_USAGE_MAX_BYTES = 32 * 1024 * 1024;
 
 let writeQueue = Promise.resolve();
 
@@ -10,6 +13,10 @@ export function usageLogPath() {
   return process.env.CCDX_USAGE_PATH || DEFAULT_USAGE_PATH;
 }
 
+export function usageLogMaxBytes(env = process.env) {
+  return parseByteLimit(env.CCDX_USAGE_MAX_BYTES, DEFAULT_USAGE_MAX_BYTES);
+}
+
 function numberOrUndefined(value) {
   return Number.isFinite(value) ? value : undefined;
 }
@@ -119,6 +126,7 @@ export function recordUsage(record) {
     .catch(() => {})
     .then(async () => {
       await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+      rotateFileIfNeededSync(filePath, Buffer.byteLength(line), usageLogMaxBytes());
       await fs.promises.appendFile(filePath, line, { encoding: "utf8", mode: 0o600 });
     })
     .catch((e) => console.error(`codex-copilot-dx usage log write failed: ${e.message}`));
@@ -137,14 +145,34 @@ export async function flushUsageWritesForTests() {
   await writeQueue;
 }
 
-export async function readUsageRecords(filePath = usageLogPath()) {
+export async function flushUsageWrites() {
+  await writeQueue;
+}
+
+async function* iterateUsageRecords(filePath) {
+  let input;
   try {
-    const text = await fs.promises.readFile(filePath, "utf8");
-    return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
+    input = fs.createReadStream(filePath, { encoding: "utf8" });
+    await new Promise((resolve, reject) => {
+      input.once("open", resolve);
+      input.once("error", reject);
+    });
   } catch (e) {
-    if (e.code === "ENOENT") return [];
+    input?.destroy();
+    if (e?.code === "ENOENT") return;
     throw e;
   }
+
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (line) yield JSON.parse(line);
+  }
+}
+
+export async function readUsageRecords(filePath = usageLogPath()) {
+  const records = [];
+  for await (const record of iterateUsageRecords(filePath)) records.push(record);
+  return records;
 }
 
 function addUsageTotals(target, usage = {}) {
@@ -154,21 +182,37 @@ function addUsageTotals(target, usage = {}) {
 }
 
 export function summarizeUsage(records) {
-  const totals = {};
-  const byModel = new Map();
+  const summary = { requests: 0, totals: {}, byModel: {} };
   for (const record of records) {
-    addUsageTotals(totals, record.usage);
+    summary.requests += 1;
+    addUsageTotals(summary.totals, record.usage);
     if (record.copilot_usage) {
-      totals.copilot_total_tokens = (totals.copilot_total_tokens || 0) + (record.copilot_usage.total_tokens || 0);
-      totals.total_nano_aiu = (totals.total_nano_aiu || 0) + (record.copilot_usage.total_nano_aiu || 0);
+      summary.totals.copilot_total_tokens = (summary.totals.copilot_total_tokens || 0) + (record.copilot_usage.total_tokens || 0);
+      summary.totals.total_nano_aiu = (summary.totals.total_nano_aiu || 0) + (record.copilot_usage.total_nano_aiu || 0);
     }
     const model = record.model || "unknown";
-    if (!byModel.has(model)) byModel.set(model, { requests: 0 });
-    const modelTotals = byModel.get(model);
+    if (!summary.byModel[model]) summary.byModel[model] = { requests: 0 };
+    const modelTotals = summary.byModel[model];
     modelTotals.requests += 1;
     addUsageTotals(modelTotals, record.usage);
   }
-  return { requests: records.length, totals, byModel: Object.fromEntries(byModel) };
+  return summary;
+}
+
+export async function summarizeUsageLogs(filePath = usageLogPath()) {
+  const summary = { requests: 0, totals: {}, byModel: {} };
+  for (const candidate of [rotatedFilePath(filePath), filePath]) {
+    for await (const record of iterateUsageRecords(candidate)) {
+      const one = summarizeUsage([record]);
+      summary.requests += one.requests;
+      addUsageTotals(summary.totals, one.totals);
+      for (const [model, values] of Object.entries(one.byModel)) {
+        if (!summary.byModel[model]) summary.byModel[model] = { requests: 0 };
+        addUsageTotals(summary.byModel[model], values);
+      }
+    }
+  }
+  return summary;
 }
 
 function fmt(n) {
@@ -176,8 +220,7 @@ function fmt(n) {
 }
 
 export async function printUsageSummary() {
-  const records = await readUsageRecords();
-  const summary = summarizeUsage(records);
+  const summary = await summarizeUsageLogs();
   console.log(`Usage log: ${usageLogPath()}`);
   if (summary.requests === 0) {
     console.log("No usage records yet.");