codex-copilot-dx 0.4.4 → 0.4.6

package/README.md

@@ -28,7 +28,7 @@ npx codex-copilot-dx@latest
 On first run, it will:
 1. Authenticate with GitHub via device flow (if needed)
 2. Print the local package version and warn when a newer npm release is available
-3. Start the adapter (port `2026`)
+3. Start the adapter on loopback (`127.0.0.1:2026`)
 4. Configure Codex (`~/.codex/config.toml`) to use the adapter, including stale shell env base URLs if present
 5. Configure Claude Code (`~/.claude/settings.json`) to use the adapter; it creates the file when missing, otherwise backs up `settings.json.bak` before updating the local API env keys
 6. Launch Codex Desktop
@@ -43,10 +43,15 @@ Environment variables:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
+| `ADAPTER_HOST` | `127.0.0.1` | Host for the adapter; set `0.0.0.0` only if you knowingly expose it on a trusted network |
 | `ADAPTER_PORT` | `2026` | Port for the adapter |
+| `CCDX_MAX_BODY_BYTES` | `134217728` | Maximum compressed/raw request body size |
+| `CCDX_MAX_DECODED_BODY_BYTES` | `268435456` | Maximum decoded request body size after decompression |
+| `CCDX_UPSTREAM_TIMEOUT_MS` | `120000` | Timeout for non-streaming upstream Copilot requests |
 | `CCDX_IMG_MAX_DIM` | `2048` | Max long edge in pixels for image downscaling |
 | `CCDX_IMG_QUALITY` | `85` | WebP quality used when re-encoding images |
 | `CCDX_IMG_MIN_BYTES` | `100000` | Images smaller than this are left untouched |
+| `CCDX_IMG_CONCURRENCY` | `4` | Concurrent image optimization tasks; values above `12` are capped at `12` |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
 | `CCDX_USAGE_PATH` | `~/.local/share/codex-copilot-dx/usage.jsonl` | Local JSONL token usage log |
 | `CCDX_DISABLE_USAGE` | unset | Set to `1` to disable usage logging |

package/bin/cli.mjs

@@ -10,9 +10,14 @@ import { printUsageSummary } from "../src/usage.mjs";
 import { checkForUpdate, localPackageVersion } from "../src/version.mjs";
 
 const ADAPTER_PORT = parseInt(process.env.ADAPTER_PORT || "2026");
+const ADAPTER_HOST = process.env.ADAPTER_HOST || "127.0.0.1";
 const LOCAL_VERSION = localPackageVersion();
 const command = process.argv[2];
 
+function isLoopbackHost(host) {
+  return ["127.0.0.1", "localhost", "::1"].includes(String(host).toLowerCase());
+}
+
 if (command === "--version" || command === "-v" || command === "version") {
   console.log(`codex-copilot-dx v${LOCAL_VERSION}`);
   process.exit(0);
@@ -41,8 +46,12 @@ try {
   // Refresh the VS Code version in the background; fallback is non-blocking.
   refreshVSCodeVersion();
 
+  if (!isLoopbackHost(ADAPTER_HOST)) {
+    console.log(status("warn", `ADAPTER_HOST=${ADAPTER_HOST} exposes the adapter beyond loopback. Use only on trusted networks.`));
+  }
+
   // Start the in-process adapter.
-  await startAdapter(ADAPTER_PORT);
+  await startAdapter(ADAPTER_PORT, ADAPTER_HOST);
 
   // Point Codex and Claude Code at the adapter.
   ensureCodexConfig(ADAPTER_PORT);
@@ -54,7 +63,7 @@ try {
   console.log(`
   ${status("ok", "Ready. Codex and Claude Code are using your GitHub Copilot subscription.")}
 
-  Adapter: http://localhost:${ADAPTER_PORT}
+  Adapter: http://${ADAPTER_HOST}:${ADAPTER_PORT}
 
   Press Ctrl+C to stop.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Use Codex Desktop app with your GitHub Copilot subscription",
   "type": "module",
   "bin": {

package/src/adapter.mjs

@@ -21,11 +21,23 @@ const RESPONSES_ONLY = new Set([
 
 const RESPONSE_HISTORY_LIMIT = 64;
 const responseHistories = new Map();
+const DEFAULT_MAX_BODY_BYTES = 128 * 1024 * 1024;
+const DEFAULT_MAX_DECODED_BODY_BYTES = 256 * 1024 * 1024;
+const DEFAULT_UPSTREAM_TIMEOUT_MS = 120 * 1000;
 const gunzipAsync = promisify(zlib.gunzip);
 const inflateAsync = promisify(zlib.inflate);
 const brotliDecompressAsync = promisify(zlib.brotliDecompress);
 const zstdDecompressAsync = zlib.zstdDecompress ? promisify(zlib.zstdDecompress) : null;
 
+function positiveInt(value, fallback) {
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+const MAX_BODY_BYTES = positiveInt(process.env.CCDX_MAX_BODY_BYTES, DEFAULT_MAX_BODY_BYTES);
+const MAX_DECODED_BODY_BYTES = positiveInt(process.env.CCDX_MAX_DECODED_BODY_BYTES, DEFAULT_MAX_DECODED_BODY_BYTES);
+const UPSTREAM_TIMEOUT_MS = positiveInt(process.env.CCDX_UPSTREAM_TIMEOUT_MS, DEFAULT_UPSTREAM_TIMEOUT_MS);
+
 export function requestPath(reqUrl) {
   return new URL(reqUrl || "/", "http://localhost").pathname;
 }
@@ -34,15 +46,45 @@ function cloneJson(value) {
   return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 
-async function readRequestBuffer(req) {
+function httpError(message, statusCode) {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  return err;
+}
+
+function payloadTooLarge(kind, maxBytes) {
+  return httpError(`${kind} request body exceeds ${maxBytes} bytes`, 413);
+}
+
+async function readRequestBuffer(req, maxBytes) {
+  const contentLength = Number.parseInt(req.headers?.["content-length"] || "", 10);
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw payloadTooLarge("Raw", maxBytes);
+  }
+
   const chunks = [];
+  let total = 0;
   for await (const chunk of req) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buf.length;
+    if (total > maxBytes) throw payloadTooLarge("Raw", maxBytes);
+    chunks.push(buf);
   }
   return Buffer.concat(chunks);
 }
 
-async function decodeRequestBuffer(buffer, contentEncoding) {
+async function decompressBody(decompress, buffer, maxBytes) {
+  try {
+    return await decompress(buffer, { maxOutputLength: maxBytes });
+  } catch (e) {
+    if (e?.code === "ERR_BUFFER_TOO_LARGE" || /maxOutputLength/i.test(e?.message || "")) {
+      throw payloadTooLarge("Decoded", maxBytes);
+    }
+    throw e;
+  }
+}
+
+async function decodeRequestBuffer(buffer, contentEncoding, maxBytes) {
   const encodings = String(contentEncoding || "identity")
     .split(",")
     .map((v) => v.trim().toLowerCase())
@@ -52,27 +94,86 @@ async function decodeRequestBuffer(buffer, contentEncoding) {
   for (const encoding of encodings.reverse()) {
     if (encoding === "identity") continue;
     if (encoding === "gzip" || encoding === "x-gzip") {
-      decoded = await gunzipAsync(decoded);
+      decoded = await decompressBody(gunzipAsync, decoded, maxBytes);
     } else if (encoding === "deflate") {
-      decoded = await inflateAsync(decoded);
+      decoded = await decompressBody(inflateAsync, decoded, maxBytes);
     } else if (encoding === "br") {
-      decoded = await brotliDecompressAsync(decoded);
+      decoded = await decompressBody(brotliDecompressAsync, decoded, maxBytes);
     } else if (encoding === "zstd") {
       if (!zstdDecompressAsync) throw new Error("Unsupported Content-Encoding: zstd");
-      decoded = await zstdDecompressAsync(decoded);
+      decoded = await decompressBody(zstdDecompressAsync, decoded, maxBytes);
     } else {
       throw new Error(`Unsupported Content-Encoding: ${encoding}`);
     }
+    if (decoded.length > maxBytes) throw payloadTooLarge("Decoded", maxBytes);
   }
+  if (decoded.length > maxBytes) throw payloadTooLarge("Decoded", maxBytes);
   return decoded;
 }
 
-export async function readJsonBody(req) {
-  const buffer = await readRequestBuffer(req);
-  const decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"]);
+export async function readJsonBody(req, {
+  maxBodyBytes = MAX_BODY_BYTES,
+  maxDecodedBodyBytes = MAX_DECODED_BODY_BYTES,
+} = {}) {
+  const buffer = await readRequestBuffer(req, maxBodyBytes);
+  const decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
   return JSON.parse(decoded.toString("utf8"));
 }
 
+function sendJsonError(res, err, fallbackStatus = 400) {
+  if (!res.headersSent) res.writeHead(err?.statusCode || fallbackStatus, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: err?.message || "Request failed" }));
+}
+
+function sendUpstreamError(res, resp, text) {
+  if (!res.headersSent) {
+    res.writeHead(resp.status || 502, { "Content-Type": resp.headers?.get("content-type") || "application/json" });
+  }
+  res.end(text || JSON.stringify({ error: "Upstream request failed" }));
+}
+
+export function writeOrDrain(res, chunk) {
+  if (res.destroyed || res.writableEnded) return Promise.resolve(false);
+  if (res.write(chunk)) return Promise.resolve(true);
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      res.off("drain", onDrain);
+      res.off("error", onError);
+      res.off("close", onClose);
+    };
+    const onDrain = () => { cleanup(); resolve(true); };
+    const onClose = () => { cleanup(); resolve(false); };
+    const onError = (err) => { cleanup(); reject(err); };
+    res.once("drain", onDrain);
+    res.once("close", onClose);
+    res.once("error", onError);
+  });
+}
+
+function createRequestAbort(req, res) {
+  const controller = new AbortController();
+  let timer = null;
+  let cleaned = false;
+  const abort = () => {
+    if (!cleaned && !controller.signal.aborted) controller.abort();
+  };
+  req.on("aborted", abort);
+  res.on("close", abort);
+  return {
+    signal: controller.signal,
+    setTimeout(ms) {
+      if (timer) clearTimeout(timer);
+      if (ms > 0) timer = setTimeout(abort, ms);
+    },
+    cleanup() {
+      cleaned = true;
+      if (timer) clearTimeout(timer);
+      req.off("aborted", abort);
+      res.off("close", abort);
+    },
+  };
+}
+
 function responsesInputItems(input) {
   if (input === undefined || input === null) return [];
   if (typeof input === "string") {
@@ -86,6 +187,81 @@ function responsesOutputItems(output) {
   return cloneJson(output.filter((item) => item?.type === "message" || item?.type === "function_call"));
 }
 
+function stripEncryptedReasoningValue(value, state) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripEncryptedReasoningValue(item, state));
+  }
+
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "encrypted_content") {
+        state.changed = true;
+        continue;
+      }
+      out[key] = stripEncryptedReasoningValue(child, state);
+    }
+    return out;
+  }
+
+  return value;
+}
+
+function isEncryptedReasoningInputItem(item) {
+  return item && typeof item === "object"
+    && (item.type === "reasoning" || Object.prototype.hasOwnProperty.call(item, "encrypted_content"));
+}
+
+export function sanitizeEncryptedReasoningRequest(reqContext) {
+  const state = { changed: false };
+  let body = cloneJson(reqContext.body);
+  if (Array.isArray(body.input)) {
+    const input = [];
+    for (const item of body.input) {
+      if (isEncryptedReasoningInputItem(item)) {
+        state.changed = true;
+        continue;
+      }
+      input.push(stripEncryptedReasoningValue(item, state));
+    }
+    body.input = input;
+  } else {
+    body = stripEncryptedReasoningValue(body, state);
+  }
+  if (!state.changed) return null;
+  return {
+    ...reqContext,
+    body,
+    inputItems: Array.isArray(body.input) ? body.input : reqContext.inputItems,
+  };
+}
+
+export function isEncryptedContentVerificationError(statusCode, text) {
+  if (statusCode < 400 || !text) return false;
+  const lower = String(text).toLowerCase();
+  return lower.includes("encrypted content")
+    && lower.includes("could not be verified")
+    && (lower.includes("could not be decrypted") || lower.includes("could not be parsed"));
+}
+
+export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
+  let resp = await upstream(reqContext.body, { signal: options.signal });
+  if (resp.ok) return { resp, reqContext };
+
+  const errorText = await resp.text();
+  if (!isEncryptedContentVerificationError(resp.status, errorText)) {
+    return { resp, reqContext, errorText };
+  }
+
+  const retryContext = sanitizeEncryptedReasoningRequest(reqContext);
+  if (!retryContext) return { resp, reqContext, errorText };
+
+  console.warn(status("warn", "encrypted reasoning rejected by upstream; retrying without encrypted reasoning"));
+  resp = await upstream(retryContext.body, { signal: options.signal });
+  if (resp.ok) return { resp, reqContext: retryContext };
+  return { resp, reqContext: retryContext, errorText: await resp.text() };
+}
+
 export function clearResponseHistoryForTests() {
   responseHistories.clear();
 }
@@ -161,8 +337,14 @@ function readSseEvents(buffer, onData) {
   }
 }
 
-async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses) {
-  const resp = await upstream(reqContext.body);
+async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses, options = {}) {
+  const opened = await openCopilotResponse(reqContext, upstream, options);
+  const { resp, errorText } = opened;
+  reqContext = opened.reqContext;
+  if (errorText !== undefined) {
+    sendUpstreamError(res, resp, errorText);
+    return;
+  }
 
   if (reqContext.body.stream) {
     res.writeHead(resp.status, {
@@ -183,7 +365,7 @@ async function proxyCopilotResponses(reqContext, req, res, upstream = copilotRes
       }
       buffer += decoder.decode(value, { stream: true });
       buffer = readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
-      res.write(value);
+      await writeOrDrain(res, value);
     }
   } else {
     const data = await resp.text();
@@ -260,11 +442,11 @@ function chatToResponses(chatResp, model) {
   return { id, object: "response", status: "completed", model: chatResp.model || model, output, usage: chatResp.usage ? { input_tokens: chatResp.usage.prompt_tokens || 0, output_tokens: chatResp.usage.completion_tokens || 0, total_tokens: chatResp.usage.total_tokens || 0 } : undefined };
 }
 
-async function forwardToChat(chatReq, emitEvent, onDone, onError) {
+async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
   let resp;
   try {
-    resp = await chatCompletions({ ...chatReq, stream: true });
+    resp = await chatCompletions({ ...chatReq, stream: true }, { signal: options.signal });
   } catch (e) {
     onError(502, e.message);
     return;
@@ -276,37 +458,37 @@ async function forwardToChat(chatReq, emitEvent, onDone, onError) {
   const respId = `resp_${uid()}`, itemId = `item_${uid()}`;
   let actualModel = "unknown", fullText = "", toolCalls = {}, hasToolCalls = false;
 
-  emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
-  emitEvent("response.output_item.added", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "in_progress", content: [] } });
-  emitEvent("response.content_part.added", { output_index: 0, content_index: 0, part: { type: "output_text", text: "" } });
+  await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
+  await emitEvent("response.output_item.added", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "in_progress", content: [] } });
+  await emitEvent("response.content_part.added", { output_index: 0, content_index: 0, part: { type: "output_text", text: "" } });
 
-  const emitCompleted = () => {
+  const emitCompleted = async () => {
     if (!hasToolCalls) {
-      emitEvent("response.output_text.done", { output_index: 0, content_index: 0, text: fullText });
-      emitEvent("response.output_item.done", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] } });
+      await emitEvent("response.output_text.done", { output_index: 0, content_index: 0, text: fullText });
+      await emitEvent("response.output_item.done", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] } });
     }
     const output = hasToolCalls
       ? Object.entries(toolCalls).map(([id, tc]) => ({ type: "function_call", id, call_id: id, name: tc.name, arguments: tc.arguments, status: "completed" }))
       : [{ type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] }];
-    emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
+    await emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
   };
 
   try {
     for await (const line of webStreamLines(resp)) {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6).trim();
-      if (data === "[DONE]") { emitCompleted(); onDone(); return; }
+      if (data === "[DONE]") { await emitCompleted(); onDone(); return; }
       let parsed;
       try { parsed = JSON.parse(data); } catch { continue; }
       if (parsed.model) actualModel = parsed.model;
       const delta = parsed.choices?.[0]?.delta;
       if (!delta) continue;
-      if (delta.content) { fullText += delta.content; emitEvent("response.output_text.delta", { output_index: 0, content_index: 0, delta: delta.content }); }
+      if (delta.content) { fullText += delta.content; await emitEvent("response.output_text.delta", { output_index: 0, content_index: 0, delta: delta.content }); }
       if (delta.tool_calls) {
         hasToolCalls = true;
         for (const tc of delta.tool_calls) {
           const id = tc.id || Object.keys(toolCalls)[tc.index] || `call_${tc.index}`;
-          if (!toolCalls[id]) { toolCalls[id] = { name: "", arguments: "" }; emitEvent("response.output_item.added", { output_index: Object.keys(toolCalls).length - 1, item: { type: "function_call", id, call_id: id, name: tc.function?.name || "", arguments: "", status: "in_progress" } }); }
+          if (!toolCalls[id]) { toolCalls[id] = { name: "", arguments: "" }; await emitEvent("response.output_item.added", { output_index: Object.keys(toolCalls).length - 1, item: { type: "function_call", id, call_id: id, name: tc.function?.name || "", arguments: "", status: "in_progress" } }); }
           if (tc.function?.name) toolCalls[id].name += tc.function.name;
           if (tc.function?.arguments) toolCalls[id].arguments += tc.function.arguments;
         }
@@ -316,42 +498,44 @@ async function forwardToChat(chatReq, emitEvent, onDone, onError) {
     onError(500, e?.message || "upstream stream error");
     return;
   }
-  emitCompleted();
+  await emitCompleted();
   onDone();
 }
 
 // Public server entry point.
 
-export function startAdapter(port = 2026) {
+export function startAdapter(port = 2026, host = "127.0.0.1") {
   const server = http.createServer((req, res) => {
     const pathname = requestPath(req.url);
 
     if (req.method === "POST" && pathname === "/v1/responses") {
       (async () => {
+        const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
+          if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
           const prepared = prepareResponsesRequest(parsed);
           prepared.surface = "responses";
           const model = parsed.model || "unknown";
           console.log(status("info", `responses model=${model} stream=${!!parsed.stream}`));
           if (RESPONSES_ONLY.has(model)) {
-            await proxyCopilotResponses(prepared, req, res);
+            await proxyCopilotResponses(prepared, req, res, copilotResponses, { signal: abort.signal });
           } else {
             const chatReq = responsesToChat(prepared.body);
             if (parsed.stream) {
-              forwardToChat(chatReq, (event, data) => {
+              await forwardToChat(chatReq, async (event, data) => {
                 if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
-                res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+                await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
                 if (event === "response.completed") {
                   rememberResponseHistory(prepared, data.response);
                   recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
                 }
-              }, () => { if (!res.writableEnded) res.end(); }, (status, errMsg) => { if (!res.headersSent) res.writeHead(status || 500); res.end(errMsg); });
+              }, () => { if (!res.writableEnded) res.end(); }, (status, errMsg) => { if (!res.headersSent) res.writeHead(status || 500); res.end(errMsg); }, { signal: abort.signal });
             } else {
               chatReq.stream = false;
               delete chatReq.max_tokens;
               try {
-                const upstream = await chatCompletions({ ...chatReq, stream: false });
+                const upstream = await chatCompletions({ ...chatReq, stream: false }, { signal: abort.signal });
                 const data = await upstream.text();
                 const resp = chatToResponses(JSON.parse(data), model);
                 rememberResponseHistory(prepared, resp);
@@ -366,8 +550,9 @@ export function startAdapter(port = 2026) {
           }
         } catch (e) {
           console.error(status("err", `Responses request failed: ${e.message}`));
-          if (!res.headersSent) res.writeHead(400);
-          res.end(JSON.stringify({ error: e.message }));
+          sendJsonError(res, e);
+        } finally {
+          abort.cleanup();
         }
       })();
       return;
@@ -375,38 +560,46 @@ export function startAdapter(port = 2026) {
 
     if (req.method === "POST" && pathname === "/v1/responses/compact") {
       (async () => {
+        const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
+          if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
           const prepared = prepareResponsesRequest(parsed);
           prepared.surface = "responses_compact";
           const model = parsed.model || "unknown";
           console.log(status("info", `responses compact model=${model} stream=${!!parsed.stream}`));
-          await proxyCopilotResponses(prepared, req, res, copilotResponsesCompact);
+          await proxyCopilotResponses(prepared, req, res, copilotResponsesCompact, { signal: abort.signal });
         } catch (e) {
           console.error(status("err", `Responses compact request failed: ${e.message}`));
-          if (!res.headersSent) res.writeHead(400);
-          res.end(JSON.stringify({ error: e.message }));
+          sendJsonError(res, e);
+        } finally {
+          abort.cleanup();
         }
       })();
       return;
     }
 
     if (req.method === "GET" && pathname === "/v1/models") {
-      listModels()
+      const abort = createRequestAbort(req, res);
+      abort.setTimeout(UPSTREAM_TIMEOUT_MS);
+      listModels({ signal: abort.signal })
         .then(({ status, body }) => { res.writeHead(status, { "Content-Type": "application/json" }); res.end(body); })
-        .catch((e) => { if (!res.headersSent) res.writeHead(502); res.end(JSON.stringify({ error: e.message })); });
+        .catch((e) => { if (!res.headersSent) res.writeHead(502); res.end(JSON.stringify({ error: e.message })); })
+        .finally(() => abort.cleanup());
       return;
     }
 
     if (req.method === "POST" && pathname === "/v1/messages/count_tokens") {
       (async () => {
+        const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify(countTokens(parsed)));
         } catch (e) {
-          if (!res.headersSent) res.writeHead(400);
-          res.end(JSON.stringify({ error: e.message }));
+          sendJsonError(res, e);
+        } finally {
+          abort.cleanup();
         }
       })();
       return;
@@ -414,13 +607,15 @@ export function startAdapter(port = 2026) {
 
     if (req.method === "POST" && pathname === "/v1/messages") {
       (async () => {
+        const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
+          if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
           const model = parsed.model || "unknown";
           console.log(status("info", `messages model=${model} stream=${!!parsed.stream}`));
           const chatReq = anthropicToChat(parsed);
           if (parsed.stream) {
-            const upstream = await chatCompletions({ ...chatReq, stream: true });
+            const upstream = await chatCompletions({ ...chatReq, stream: true }, { signal: abort.signal });
             if (!upstream.ok) {
               if (!res.headersSent) res.writeHead(upstream.status);
               res.end(await upstream.text());
@@ -431,17 +626,17 @@ export function startAdapter(port = 2026) {
             let usage;
             await streamAnthropicFromLines(
               webStreamLines(upstream),
-              (event, data) => {
+              async (event, data) => {
                 if (event === "message_start") messageId = data.message?.id;
                 if (event === "message_delta") usage = data.usage;
-                res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+                await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
               },
               model,
             );
             recordAnthropicUsage({ surface: "messages", mode: "stream", model, responseId: messageId, usage });
             if (!res.writableEnded) res.end();
           } else {
-            const upstream = await chatCompletions({ ...chatReq, stream: false });
+            const upstream = await chatCompletions({ ...chatReq, stream: false }, { signal: abort.signal });
             const data = await upstream.text();
             const anthropicMsg = chatToAnthropic(JSON.parse(data), model);
             recordAnthropicUsage({ surface: "messages", mode: "json", model: anthropicMsg.model, responseId: anthropicMsg.id, usage: anthropicMsg.usage });
@@ -450,8 +645,9 @@ export function startAdapter(port = 2026) {
           }
         } catch (e) {
           console.error(status("err", `Messages request failed: ${e.message}`));
-          if (!res.headersSent) res.writeHead(400);
-          res.end(JSON.stringify({ error: e.message }));
+          sendJsonError(res, e);
+        } finally {
+          abort.cleanup();
         }
       })();
       return;
@@ -472,8 +668,9 @@ export function startAdapter(port = 2026) {
   });
 
   return new Promise((resolve) => {
-    server.listen(port, () => {
-      console.log(status("ok", `Adapter listening on http://localhost:${port}`));
+    server.listen(port, host, () => {
+      const actualPort = server.address()?.port || port;
+      console.log(status("ok", `Adapter listening on http://${host}:${actualPort}`));
       resolve(server);
     });
   });

package/src/anthropic.mjs

@@ -163,26 +163,26 @@ export async function streamAnthropicFromLines(lineIterator, emit, model) {
   let sawToolUse = false;
   let outputTokens = 0;
 
-  const ensureStart = () => {
+  const ensureStart = async () => {
     if (started) return;
     started = true;
-    emit("message_start", { type: "message_start", message: {
+    await emit("message_start", { type: "message_start", message: {
       id: msgId, type: "message", role: "assistant", model: actualModel,
       content: [], stop_reason: null, stop_sequence: null,
       usage: { input_tokens: 0, output_tokens: 0 },
     } });
   };
 
-  const openText = () => {
+  const openText = async () => {
     if (textOpen) return;
     blockIndex += 1;
     textOpen = true;
-    emit("content_block_start", { type: "content_block_start", index: blockIndex,
+    await emit("content_block_start", { type: "content_block_start", index: blockIndex,
       content_block: { type: "text", text: "" } });
   };
-  const closeText = () => {
+  const closeText = async () => {
     if (!textOpen) return;
-    emit("content_block_stop", { type: "content_block_stop", index: blockIndex });
+    await emit("content_block_stop", { type: "content_block_stop", index: blockIndex });
     textOpen = false;
   };
 
@@ -197,27 +197,27 @@ export async function streamAnthropicFromLines(lineIterator, emit, model) {
     const choice = parsed.choices?.[0];
     if (!choice) continue;
     const delta = choice.delta || {};
-    ensureStart();
+    await ensureStart();
 
     if (delta.content && !sawToolUse) {
-      openText();
-      emit("content_block_delta", { type: "content_block_delta", index: blockIndex,
+      await openText();
+      await emit("content_block_delta", { type: "content_block_delta", index: blockIndex,
         delta: { type: "text_delta", text: delta.content } });
     }
 
     if (Array.isArray(delta.tool_calls)) {
       sawToolUse = true;
-      closeText();
+      await closeText();
       for (const tc of delta.tool_calls) {
         const oi = tc.index ?? 0;
         if (!toolBlocks[oi]) {
           blockIndex += 1;
           toolBlocks[oi] = { anthropicIndex: blockIndex };
-          emit("content_block_start", { type: "content_block_start", index: blockIndex,
+          await emit("content_block_start", { type: "content_block_start", index: blockIndex,
             content_block: { type: "tool_use", id: tc.id || `tu_${uid()}`, name: tc.function?.name || "", input: {} } });
         }
         if (tc.function?.arguments) {
-          emit("content_block_delta", { type: "content_block_delta", index: toolBlocks[oi].anthropicIndex,
+          await emit("content_block_delta", { type: "content_block_delta", index: toolBlocks[oi].anthropicIndex,
             delta: { type: "input_json_delta", partial_json: tc.function.arguments } });
         }
       }
@@ -226,16 +226,16 @@ export async function streamAnthropicFromLines(lineIterator, emit, model) {
     if (choice.finish_reason) finishReason = choice.finish_reason;
   }
 
-  ensureStart();
-  if (textOpen) closeText();
+  await ensureStart();
+  if (textOpen) await closeText();
   for (const oi of Object.keys(toolBlocks)) {
-    emit("content_block_stop", { type: "content_block_stop", index: toolBlocks[oi].anthropicIndex });
+    await emit("content_block_stop", { type: "content_block_stop", index: toolBlocks[oi].anthropicIndex });
   }
 
   const stop_reason = finishReason ? mapStopReason(finishReason) : (sawToolUse ? "tool_use" : "end_turn");
-  emit("message_delta", { type: "message_delta", delta: { stop_reason, stop_sequence: null },
+  await emit("message_delta", { type: "message_delta", delta: { stop_reason, stop_sequence: null },
     usage: { output_tokens: outputTokens } });
-  emit("message_stop", { type: "message_stop" });
+  await emit("message_stop", { type: "message_stop" });
 }
 
 // Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.

package/src/claude-config.mjs

@@ -7,7 +7,7 @@ const SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
 
 // Return an updated settings object without mutating the input.
 export function computeUpdatedSettings(settings, port) {
-  const target = `http://localhost:${port}`;
+  const target = `http://127.0.0.1:${port}`;
   const current = settings?.env?.ANTHROPIC_BASE_URL;
   const currentToken = settings?.env?.ANTHROPIC_AUTH_TOKEN;
   const changed = current !== target || currentToken !== "dummy";
@@ -24,7 +24,7 @@ export function computeUpdatedSettings(settings, port) {
 
 // Point Claude Code at the adapter by updating ~/.claude/settings.json.
 export function ensureClaudeConfig(port = 2026) {
-  const target = `http://localhost:${port}`;
+  const target = `http://127.0.0.1:${port}`;
 
   if (!fs.existsSync(SETTINGS_PATH)) {
     fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });

package/src/config.mjs

@@ -33,8 +33,8 @@ function setTomlKey(lines, sectionName, key, value) {
 }
 
 export function computeUpdatedCodexConfig(content, adapterPort = 2026) {
-  const baseUrl = `http://localhost:${adapterPort}/v1`;
-  const anthropicBaseUrl = `http://localhost:${adapterPort}`;
+  const baseUrl = `http://127.0.0.1:${adapterPort}/v1`;
+  const anthropicBaseUrl = `http://127.0.0.1:${adapterPort}`;
   const hadTrailingNewline = content.endsWith("\n");
   const lines = content.split("\n");
   if (hadTrailingNewline) lines.pop();
@@ -59,8 +59,8 @@ export function computeUpdatedCodexConfig(content, adapterPort = 2026) {
 }
 
 function initialCodexConfig(adapterPort) {
-  const baseUrl = `http://localhost:${adapterPort}/v1`;
-  const anthropicBaseUrl = `http://localhost:${adapterPort}`;
+  const baseUrl = `http://127.0.0.1:${adapterPort}/v1`;
+  const anthropicBaseUrl = `http://127.0.0.1:${adapterPort}`;
   return `openai_base_url = "${baseUrl}"
 
 [shell_environment_policy]
@@ -75,7 +75,7 @@ OPENAI_API_KEY = "dummy"
 }
 
 export function ensureCodexConfig(adapterPort = 2026) {
-  const baseUrl = `http://localhost:${adapterPort}/v1`;
+  const baseUrl = `http://127.0.0.1:${adapterPort}/v1`;
 
   if (!fs.existsSync(CONFIG_PATH)) {
     // Codex config does not exist yet; create the local proxy defaults.

package/src/copilot.mjs

@@ -10,9 +10,17 @@ let apiBase = DEFAULT_API_BASE;
 const IMG_MAX_DIM = parseInt(process.env.CCDX_IMG_MAX_DIM || "2048", 10);
 const IMG_QUALITY = parseInt(process.env.CCDX_IMG_QUALITY || "85", 10);
 const IMG_MIN_BYTES = 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;
+}
+
 export function parseApiBase(data) {
   return (data && data.endpoints && typeof data.endpoints.api === "string" && data.endpoints.api)
     ? data.endpoints.api
@@ -59,14 +67,26 @@ export async function optimizeImageDataUrl(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); })());
+      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 () => {
+      tasks.push(async () => {
         const dataUrl = `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
         const opt = await optimizeImageDataUrl(dataUrl);
         const match = /^data:([^;]+);base64,(.+)$/.exec(opt);
@@ -74,7 +94,7 @@ function visitImageParts(parts, tasks) {
           part.source.media_type = match[1];
           part.source.data = match[2];
         }
-      })());
+      });
     }
   }
 }
@@ -97,13 +117,13 @@ export async function optimizeImagesInBody(reqBody) {
           try {
             const parsed = JSON.parse(trimmed);
             if (Array.isArray(parsed)) {
-              const before = tasks.length;
-              visitImageParts(parsed, tasks);
-              const localTasks = tasks.slice(before);
+              const localTasks = [];
+              visitImageParts(parsed, localTasks);
               if (localTasks.length) {
-                tasks.push(Promise.all(localTasks).then(() => {
+                tasks.push(async () => {
+                  await runWithConcurrency(localTasks, IMG_CONCURRENCY);
                   item.output = JSON.stringify(parsed);
-                }));
+                });
               }
             }
           } catch {
@@ -114,7 +134,7 @@ export async function optimizeImagesInBody(reqBody) {
     }
   }
 
-  if (tasks.length) await Promise.all(tasks);
+  if (tasks.length) await runWithConcurrency(tasks, IMG_CONCURRENCY);
   return reqBody;
 }
 
@@ -235,11 +255,12 @@ function getGithubToken() {
   return fs.readFileSync(GITHUB_TOKEN_PATH, "utf-8").trim();
 }
 
-export async function getCopilotToken() {
+export async function getCopilotToken({ signal } = {}) {
   if (copilotToken && Date.now() < copilotTokenExpiry - 60000) return copilotToken;
   const ghToken = getGithubToken();
   const resp = await fetch(`${GITHUB_API}/copilot_internal/v2/token`, {
     headers: { Authorization: `token ${ghToken}`, Accept: "application/json" },
+    signal,
   });
   if (!resp.ok) throw new Error(`Failed to get Copilot token: ${resp.status}`);
   const data = await resp.json();
@@ -254,8 +275,8 @@ export async function getCopilotToken() {
 }
 
 // chatReq is already converted by the adapter. The caller parses the raw Response.
-export async function chatCompletions(chatReq) {
-  const token = await getCopilotToken();
+export async function chatCompletions(chatReq, { signal } = {}) {
+  const token = await getCopilotToken({ signal });
   const messages = chatReq.messages || [];
   const headers = buildHeaders({
     token,
@@ -267,21 +288,22 @@ export async function chatCompletions(chatReq) {
     method: "POST",
     headers,
     body: JSON.stringify(chatReq),
+    signal,
   });
 }
 
-export async function listModels() {
-  const token = await getCopilotToken();
+export async function listModels({ signal } = {}) {
+  const token = await getCopilotToken({ signal });
   const headers = buildHeaders({
     token, version: getVSCodeVersion(), initiator: "user", vision: false,
   });
-  const resp = await fetch(`${getApiBase()}/models`, { headers });
+  const resp = await fetch(`${getApiBase()}/models`, { headers, signal });
   return { status: resp.status, body: await resp.text() };
 }
 
 // Responses-only models go directly to Copilot's /responses endpoint.
-export async function responses(reqBody) {
-  const token = await getCopilotToken();
+export async function responses(reqBody, { signal } = {}) {
+  const token = await getCopilotToken({ signal });
   const beforeBytes = Buffer.byteLength(JSON.stringify(reqBody));
   await optimizeImagesInBody(reqBody);
   const bodyBuf = Buffer.from(JSON.stringify(reqBody), "utf8");
@@ -302,6 +324,7 @@ export async function responses(reqBody) {
       method: "POST",
       headers,
       body: bodyBuf,
+      signal,
     });
   } catch (e) {
     const cause = e?.cause;
@@ -310,7 +333,7 @@ export async function responses(reqBody) {
   }
 }
 
-export async function responsesCompact(reqBody) {
+export async function responsesCompact(reqBody, options = {}) {
   // GitHub Copilot accepts Codex compact payloads on the regular Responses endpoint.
-  return responses(reqBody);
+  return responses(reqBody, options);
 }