codex-copilot-dx 0.6.15 → 0.6.18

package/src/http-transport.mjs

@@ -17,12 +17,103 @@ const MAX_INFLIGHT_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxInflightBodyBytes;
 const MAX_QUEUED_REQUESTS = HTTP_RUNTIME_CONFIG.maxQueuedRequests;
 const REQUEST_QUEUE_TIMEOUT_MS = HTTP_RUNTIME_CONFIG.requestQueueTimeoutMs;
 
+export const MAX_UPSTREAM_ERROR_BODY_BYTES = 1024 * 1024;
+export const MAX_UPSTREAM_MODEL_CATALOG_BYTES = 8 * 1024 * 1024;
+export const MAX_UPSTREAM_RETRY_DRAIN_BYTES = 64 * 1024;
+
 export function httpError(message, statusCode) {
   const err = new Error(message);
   err.statusCode = statusCode;
   return err;
 }
 
+function upstreamBodyTooLarge(label, maxBytes) {
+  const error = httpError(`${label} exceeds ${maxBytes} bytes`, 502);
+  error.code = "ccdx_upstream_response_too_large";
+  error.jsonBody = {
+    error: {
+      message: error.message,
+      type: "upstream_error",
+      code: error.code,
+    },
+  };
+  return error;
+}
+
+function unreadableUpstreamBody(label) {
+  const error = httpError(`${label} is not a readable web stream`, 502);
+  error.code = "ccdx_upstream_response_unreadable";
+  error.jsonBody = {
+    error: {
+      message: error.message,
+      type: "upstream_error",
+      code: error.code,
+    },
+  };
+  return error;
+}
+
+async function cancelResponseBody(response) {
+  try { await response?.body?.cancel?.(); } catch {}
+}
+
+function responseContentLength(response) {
+  const raw = response?.headers?.get?.("content-length")
+    ?? response?.headers?.["content-length"]
+    ?? response?.headers?.["Content-Length"];
+  const parsed = Number.parseInt(raw || "", 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+
+export async function readBoundedResponseBuffer(response, {
+  maxBytes,
+  label = "Upstream response body",
+} = {}) {
+  const limit = Number.isFinite(maxBytes) && maxBytes >= 0 ? Math.floor(maxBytes) : 0;
+  if (responseContentLength(response) > limit) {
+    await cancelResponseBody(response);
+    throw upstreamBodyTooLarge(label, limit);
+  }
+  if (!response?.body) {
+    if ((responseContentLength(response) || 0) > 0) throw unreadableUpstreamBody(label);
+    return Buffer.alloc(0);
+  }
+  const reader = response?.body?.getReader?.();
+  if (!reader) throw unreadableUpstreamBody(label);
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = Buffer.from(value);
+      total += chunk.length;
+      if (total > limit) {
+        await reader.cancel().catch(() => {});
+        throw upstreamBodyTooLarge(label, limit);
+      }
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks, total);
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export async function readBoundedResponseText(response, options) {
+  return new TextDecoder().decode(await readBoundedResponseBuffer(response, options));
+}
+
+export async function discardBoundedResponseBody(response, maxBytes = MAX_UPSTREAM_RETRY_DRAIN_BYTES) {
+  try {
+    await readBoundedResponseBuffer(response, { maxBytes, label: "Upstream retry response body" });
+    return true;
+  } catch {
+    await cancelResponseBody(response);
+    return false;
+  }
+}
+
 function payloadTooLarge(kind, maxBytes) {
   return httpError(`${kind} request body exceeds ${maxBytes} bytes`, 413);
 }

package/src/lock.mjs

@@ -32,23 +32,171 @@ function processIsAlive(pid) {
   }
 }
 
+function readStaleLockSnapshot(lockPath, io) {
+  const before = io.lstatSync(lockPath);
+  if (!before.isFile() || before.isSymbolicLink()) return { safe: false };
+
+  const noFollow = io.constants?.O_NOFOLLOW || 0;
+  let fd;
+  try {
+    fd = io.openSync(lockPath, io.constants.O_RDONLY | noFollow);
+    const opened = io.fstatSync(fd);
+    if (!opened.isFile()
+      || opened.dev !== before.dev
+      || opened.ino !== before.ino
+      || opened.size !== before.size) {
+      return { safe: false };
+    }
+    const text = io.readFileSync(fd, "utf8");
+    const after = io.fstatSync(fd);
+    if (after.dev !== opened.dev
+      || after.ino !== opened.ino
+      || after.size !== opened.size
+      || after.mtimeMs !== opened.mtimeMs
+      || after.ctimeMs !== opened.ctimeMs) {
+      return { safe: false };
+    }
+    let record = {};
+    try {
+      record = JSON.parse(text);
+    } catch {}
+    return {
+      safe: true,
+      dev: after.dev,
+      ino: after.ino,
+      mtimeMs: after.mtimeMs,
+      size: after.size,
+      text,
+      pid: Number(record?.pid),
+      owner: typeof record?.owner === "string" ? record.owner : "",
+    };
+  } finally {
+    if (fd !== undefined) io.closeSync(fd);
+  }
+}
+
 function sameLock(left, right) {
   return left.dev === right.dev
     && left.ino === right.ino
     && left.mtimeMs === right.mtimeMs
     && left.size === right.size
-    && left.owner === right.owner;
+    && left.owner === right.owner
+    && left.text === right.text;
 }
 
-function maybeRemoveStaleLock(lockPath, staleMs, nowMs) {
-  if (!Number.isFinite(staleMs) || staleMs <= 0) return false;
+function lockPathExists(lockPath, io) {
+  try {
+    io.lstatSync(lockPath);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+function writeLockRecord(lockPath, record, io) {
+  const fd = io.openSync(lockPath, "wx", 0o600);
+  try {
+    io.writeFileSync(fd, JSON.stringify(record));
+  } catch (error) {
+    io.closeSync(fd);
+    try { io.unlinkSync(lockPath); } catch {}
+    throw error;
+  }
+  return fd;
+}
+
+function removeOwnedLock(lockPath, owner, io) {
+  try {
+    const snapshot = readStaleLockSnapshot(lockPath, io);
+    if (snapshot.safe && snapshot.owner === owner) io.unlinkSync(lockPath);
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+}
+
+function reclaimGuardPath(lockPath) {
+  return `${lockPath}.reclaim`;
+}
+
+function acquireReclaimGuard(lockPath, io) {
+  const guardPath = reclaimGuardPath(lockPath);
+  const owner = randomUUID();
+  let fd;
+  try {
+    fd = writeLockRecord(guardPath, {
+      pid: process.pid,
+      owner,
+      created_at: new Date().toISOString(),
+    }, io);
+    io.closeSync(fd);
+    return { guardPath, owner };
+  } catch (error) {
+    if (fd !== undefined) try { io.closeSync(fd); } catch {}
+    if (error?.code === "EEXIST") return null;
+    throw error;
+  }
+}
+
+function maybeRemoveAbandonedGuard(guardPath, staleMs, nowMs, io, processAlive) {
   try {
-    const first = readLockSnapshot(lockPath);
-    if (nowMs - first.mtimeMs <= staleMs || processIsAlive(first.pid)) return false;
-    const current = readLockSnapshot(lockPath);
-    if (!sameLock(first, current)) return false;
-    fs.unlinkSync(lockPath);
+    const snapshot = readStaleLockSnapshot(guardPath, io);
+    if (!snapshot.safe || nowMs - snapshot.mtimeMs <= staleMs || processAlive(snapshot.pid)) return false;
+    const quarantinePath = `${guardPath}.stale-${randomUUID()}`;
+    io.renameSync(guardPath, quarantinePath);
+    const moved = readStaleLockSnapshot(quarantinePath, io);
+    if (!moved.safe || !sameLock(snapshot, moved)) {
+      restoreQuarantinedLock(guardPath, quarantinePath, io);
+      return false;
+    }
+    io.unlinkSync(quarantinePath);
     return true;
+  } catch (error) {
+    return error?.code === "ENOENT";
+  }
+}
+
+function restoreQuarantinedLock(lockPath, quarantinePath, io) {
+  try {
+    io.linkSync(quarantinePath, lockPath);
+  } catch {
+    return;
+  }
+  try {
+    io.unlinkSync(quarantinePath);
+  } catch {}
+}
+
+function maybeRemoveStaleLock(lockPath, staleMs, nowMs, io, processAlive) {
+  if (!Number.isFinite(staleMs) || staleMs <= 0) return false;
+  try {
+    const first = readStaleLockSnapshot(lockPath, io);
+    if (!first.safe || nowMs - first.mtimeMs <= staleMs || processAlive(first.pid)) return false;
+    const guard = acquireReclaimGuard(lockPath, io);
+    if (!guard) return false;
+    try {
+      const current = readStaleLockSnapshot(lockPath, io);
+      if (!sameLock(first, current)
+        || nowMs - current.mtimeMs <= staleMs
+        || processAlive(current.pid)) {
+        return false;
+      }
+      const quarantinePath = `${lockPath}.stale-${randomUUID()}`;
+      try {
+        io.renameSync(lockPath, quarantinePath);
+      } catch (e) {
+        return e?.code === "ENOENT";
+      }
+      const moved = readStaleLockSnapshot(quarantinePath, io);
+      if (!moved.safe || !sameLock(current, moved)) {
+        restoreQuarantinedLock(lockPath, quarantinePath, io);
+        return false;
+      }
+      io.unlinkSync(quarantinePath);
+      return true;
+    } finally {
+      removeOwnedLock(guard.guardPath, guard.owner, io);
+    }
   } catch (e) {
     if (e?.code === "ENOENT") return true;
     return false;
@@ -60,28 +208,42 @@ export async function withFileLock(lockPath, fn, {
   staleMs = 15 * 60 * 1000,
   pollMs = 50,
   now = Date.now,
+  fsImpl = fs,
+  processAlive = processIsAlive,
 } = {}) {
   fs.mkdirSync(path.dirname(lockPath), { recursive: true });
   const started = now();
   const owner = randomUUID();
   let fd = null;
+  const guardPath = reclaimGuardPath(lockPath);
 
   while (fd === null) {
+    const beforeAcquire = now();
+    if (lockPathExists(guardPath, fsImpl)) {
+      maybeRemoveAbandonedGuard(guardPath, staleMs, beforeAcquire, fsImpl, processAlive);
+      if (lockPathExists(guardPath, fsImpl)) {
+        if (beforeAcquire - started >= timeoutMs) throw new Error(`Timed out waiting for lock: ${lockPath}`);
+        await sleep(Math.min(pollMs, Math.max(1, timeoutMs - (beforeAcquire - started))));
+        continue;
+      }
+    }
     try {
-      const candidateFd = fs.openSync(lockPath, "wx", 0o600);
-      try {
-        fs.writeFileSync(candidateFd, JSON.stringify({ pid: process.pid, owner, created_at: new Date().toISOString() }));
-        fd = candidateFd;
-      } catch (e) {
-        fs.closeSync(candidateFd);
-        try { fs.unlinkSync(lockPath); } catch {}
-        throw e;
+      fd = writeLockRecord(lockPath, {
+        pid: process.pid,
+        owner,
+        created_at: new Date().toISOString(),
+      }, fs);
+      if (lockPathExists(guardPath, fsImpl)) {
+        fs.closeSync(fd);
+        fd = null;
+        removeOwnedLock(lockPath, owner, fs);
+        continue;
       }
       break;
     } catch (e) {
       if (e?.code !== "EEXIST") throw e;
       const nowMs = now();
-      if (maybeRemoveStaleLock(lockPath, staleMs, nowMs)) continue;
+      if (maybeRemoveStaleLock(lockPath, staleMs, nowMs, fsImpl, processAlive)) continue;
       if (nowMs - started >= timeoutMs) {
         throw new Error(`Timed out waiting for lock: ${lockPath}`);
       }

package/src/models.mjs

@@ -117,6 +117,23 @@ export function modelIsResponsesOnly(model) {
   return hasResponses && !endpoints.includes("/chat/completions");
 }
 
+export function resolveCopilotPriorityTierModel(model, serviceTier, models) {
+  const baseModel = String(model || "").trim();
+  if (baseModel !== "gpt-5.6-sol" || serviceTier !== "priority") return null;
+  const fastModelId = "gpt-5.6-sol-fast";
+  const fastModel = copilotModelData(models)
+    .find((entry) => String(entry?.id || "").trim() === fastModelId);
+  const vendor = String(fastModel?.vendor || fastModel?.owned_by || "").trim().toLowerCase();
+  const policy = String(fastModel?.policy?.state || "").trim().toLowerCase();
+  if (vendor !== "openai"
+    || policy !== "enabled"
+    || fastModel?.model_picker_enabled !== true
+    || !modelIsResponsesOnly(fastModel)) {
+    return null;
+  }
+  return fastModelId;
+}
+
 function copilotModelData(models) {
   const data = Array.isArray(models) ? models : models?.data;
   return Array.isArray(data) ? data : [];