codex-copilot-dx 0.9.24 → 0.9.25

package/src/proxy-tunnel.mjs

@@ -0,0 +1,102 @@
+import net from "node:net";
+import tls from "node:tls";
+import https from "node:https";
+import { networkProxyFor } from "./network-route.mjs";
+
+// A bounded read preserves bytes following the handshake for the TLS parser.
+function readSocket(socket, ready, maxBytes = 16 * 1024) {
+  return new Promise((resolve, reject) => {
+    let chunks = [], size = 0;
+    const cleanup = () => { socket.off("data", data); socket.off("error", error); socket.off("close", closed); };
+    const error = (e) => { cleanup(); reject(e); };
+    const closed = () => error(new Error("Proxy closed the connection"));
+    const data = (chunk) => {
+      chunks.push(chunk); size += chunk.length;
+      if (size > maxBytes) { error(new Error("Proxy handshake exceeds its limit")); return; }
+      const bytes = Buffer.concat(chunks, size), end = ready(bytes);
+      if (end !== null) {
+        socket.pause(); cleanup();
+        if (bytes.length > end) socket.unshift(bytes.subarray(end));
+        resolve(bytes.subarray(0, end));
+      }
+    };
+    socket.on("data", data); socket.once("error", error); socket.once("close", closed); socket.resume();
+  });
+}
+
+async function connectProxy(target, route, timeoutMs, pending) {
+  const proxy = route.url;
+  const proxyHost = proxy.hostname.replace(/^\[|\]$/g, "");
+  const socket = proxy.protocol === "https:"
+    ? tls.connect({ host: proxyHost, port: Number(proxy.port || 443), servername: net.isIP(proxyHost) ? undefined : proxyHost, rejectUnauthorized: true })
+    : net.connect({ host: proxyHost, port: Number(proxy.port || (proxy.protocol.startsWith("socks") ? 1080 : 80)) });
+  pending.add(socket);
+  const timer = setTimeout(() => socket.destroy(new Error("Proxy connection timed out")), timeoutMs);
+  socket.once("close", () => pending.delete(socket));
+  try {
+    await new Promise((resolve, reject) => {
+      const event = proxy.protocol === "https:" ? "secureConnect" : "connect";
+      const failed = (error) => { socket.off(event, connected); reject(error); };
+      const connected = () => { socket.off("error", failed); resolve(); };
+      socket.once(event, connected); socket.once("error", failed);
+    });
+    if (proxy.protocol.startsWith("socks5")) {
+      const user = Buffer.from(decodeURIComponent(proxy.username)), password = Buffer.from(decodeURIComponent(proxy.password));
+      if (user.length > 255 || password.length > 255) throw new Error("SOCKS5 proxy credentials are too long");
+      const greeting = readSocket(socket, b => b.length >= 2 ? 2 : null);
+      socket.write(user.length ? Buffer.from([5, 2, 0, 2]) : Buffer.from([5, 1, 0]));
+      const choice = await greeting;
+      if (choice[0] !== 5 || ![0, 2].includes(choice[1]) || (choice[1] === 2 && !user.length)) throw new Error("SOCKS5 proxy authentication is unsupported");
+      if (choice[1] === 2) {
+        const auth = readSocket(socket, b => b.length >= 2 ? 2 : null);
+        socket.write(Buffer.concat([Buffer.from([1, user.length]), user, Buffer.from([password.length]), password]));
+        const result = await auth; if (result[0] !== 1 || result[1] !== 0) throw new Error("SOCKS5 proxy authentication failed");
+      }
+      const host = Buffer.from(target.hostname);
+      if (host.length > 255) throw new Error("Proxy target hostname is too long");
+      const response = readSocket(socket, b => {
+        if (b.length < 5) return null;
+        const size = b[3] === 1 ? 10 : b[3] === 4 ? 22 : b[3] === 3 ? 7 + b[4] : 5;
+        return b.length >= size ? size : null;
+      });
+      socket.write(Buffer.concat([Buffer.from([5, 1, 0, 3, host.length]), host, Buffer.from([1, 187])]));
+      const result = await response;
+      if (result[0] !== 5 || result[1] !== 0 || ![1, 3, 4].includes(result[3])) throw new Error("SOCKS5 proxy rejected the connection");
+    } else {
+      const response = readSocket(socket, b => { const end = b.indexOf("\r\n\r\n"); return end < 0 ? null : end + 4; });
+      const credentials = proxy.username || proxy.password
+        ? `Proxy-Authorization: Basic ${Buffer.from(`${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`).toString("base64")}\r\n` : "";
+      socket.write(`CONNECT ${target.hostname}:443 HTTP/1.1\r\nHost: ${target.hostname}:443\r\n${credentials}\r\n`);
+      const headers = (await response).toString("latin1");
+      const status = /^HTTP\/1\.[01] (\d{3})/.exec(headers)?.[1];
+      if (status !== "200") throw new Error(`HTTP proxy rejected CONNECT (${status || "invalid response"})`);
+    }
+    clearTimeout(timer); pending.delete(socket);
+    return socket;
+  } catch (error) { clearTimeout(timer); socket.destroy(); throw error; }
+}
+
+export function createProxyAgent(plan, { timeoutMs = 30_000 } = {}) {
+  const pending = new Set();
+  let closed = false;
+  const agent = new https.Agent({ keepAlive: true, maxSockets: 32, maxFreeSockets: 4 });
+  const direct = agent.createConnection.bind(agent);
+  agent.createConnection = (options, callback) => {
+    if (closed) { queueMicrotask(() => callback(new Error("Proxy agent is closed"))); return undefined; }
+    const target = new URL(`https://${options.host}`), route = networkProxyFor(target, plan);
+    if (!route) return direct(options, callback);
+    void connectProxy(target, route, timeoutMs, pending).then(socket => {
+      if (closed) { socket.destroy(); callback(new Error("Proxy agent is closed")); return; }
+      const secure = tls.connect({ ...options, socket, rejectUnauthorized: true });
+      pending.add(secure);
+      const timer = setTimeout(() => secure.destroy(new Error("Proxy target TLS timed out")), timeoutMs);
+      const fail = (error) => { clearTimeout(timer); pending.delete(secure); secure.off("secureConnect", done); callback(error); };
+      const done = () => { clearTimeout(timer); pending.delete(secure); secure.off("error", fail); callback(null, secure); };
+      secure.once("error", fail); secure.once("secureConnect", done); secure.resume();
+    }, callback);
+    return undefined;
+  };
+  const destroy = agent.destroy.bind(agent);
+  agent.destroy = () => { closed = true; for (const socket of pending) socket.destroy(new Error("Proxy agent closed")); pending.clear(); destroy(); };
+  return agent;
+}

package/src/responses-request.mjs

@@ -309,7 +309,8 @@ export function prepareResponsesRequest(reqBody, {
   assertActive?.();
   const body = mutate ? reqBody : cloneJson(reqBody);
   assertActive?.();
-  const currentInputItems = responsesInputItems(body.input, { assertActive, clone: !mutate });
+  // body is already an owned clone unless the caller explicitly allows mutation.
+  const currentInputItems = responsesInputItems(body.input, { assertActive, clone: false });
   const currentInputRefs = new Set(
     currentInputItems.filter((item) => item && typeof item === "object"),
   );
@@ -359,7 +360,9 @@ export function prepareResponsesRequest(reqBody, {
   // concrete Copilot RoutePlan.
   if (copilotBoundary) applyCopilotResponsesRequestPolicies(body);
   stripInternalResponsesInputFields(body.input, { assertActive });
-  stripInternalResponsesInputFields(historyInputItems, { assertActive });
+  // The first pass already covers shared current items. Only an independent
+  // pre-adaptation snapshot needs another pass.
+  if (historyInputItems !== currentInputItems) stripInternalResponsesInputFields(historyInputItems, { assertActive });
   assertActive?.();
   const retainedCurrentInputStart = body.input.findIndex((item) => currentInputRefs.has(item));
 

package/src/user-settings.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
+import { withFileLockSync } from "./lock.mjs";
 import { AUTO_REVIEW_REASONING_EFFORTS, DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
 import { loadRuntimeConfig, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 import {
@@ -155,7 +156,10 @@ export function decodedBodyLimitPreference({ env = process.env, home = os.homedi
   return { bytes: RUNTIME_DEFAULTS.maxDecodedBodyBytes, mib: DECODED_BODY_LIMIT_MIN_MIB, source: "default" };
 }
 
-export function writeDecodedBodyLimitMib(mib, { env = process.env, home = os.homedir() } = {}) {
+export function writeDecodedBodyLimitMib(mib, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeDecodedBodyLimitMibUnlocked(mib, options));
+}
+function writeDecodedBodyLimitMibUnlocked(mib, { env = process.env, home = os.homedir() } = {}) {
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });
   const next = { ...settings };
@@ -177,7 +181,10 @@ export function writeDecodedBodyLimitMib(mib, { env = process.env, home = os.hom
   return { changed, filePath, ...decodedBodyLimitPreference({ env, home }) };
 }
 
-export function writeResponseHistoryLimitMib(mib, { env = process.env, home = os.homedir() } = {}) {
+export function writeResponseHistoryLimitMib(mib, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeResponseHistoryLimitMibUnlocked(mib, options));
+}
+function writeResponseHistoryLimitMibUnlocked(mib, { env = process.env, home = os.homedir() } = {}) {
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });
   const next = { ...settings };
@@ -199,7 +206,10 @@ export function writeResponseHistoryLimitMib(mib, { env = process.env, home = os
   return { changed, filePath, ...responseHistoryLimitPreference({ env, home }) };
 }
 
-export function writeAutoReviewModel(model, { env = process.env, home = os.homedir(), reasoningEffort } = {}) {
+export function writeAutoReviewModel(model, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeAutoReviewModelUnlocked(model, options));
+}
+function writeAutoReviewModelUnlocked(model, { env = process.env, home = os.homedir(), reasoningEffort } = {}) {
   if (reasoningEffort !== undefined && reasoningEffort !== null
     && !AUTO_REVIEW_REASONING_EFFORTS.includes(reasoningEffort)) {
     throw new Error("Auto-review reasoning effort is invalid");
@@ -220,7 +230,10 @@ export function writeAutoReviewModel(model, { env = process.env, home = os.homed
   return { changed, filePath, model: value || DEFAULT_CODEX_AUTO_REVIEW_MODEL };
 }
 
-export function writeTerminalAnimationTheme(theme, { env = process.env, home = os.homedir() } = {}) {
+export function writeTerminalAnimationTheme(theme, options = {}) {
+  return withFileLockSync(`${userSettingsPath(options)}.lock`, () => writeTerminalAnimationThemeUnlocked(theme, options));
+}
+function writeTerminalAnimationThemeUnlocked(theme, { env = process.env, home = os.homedir() } = {}) {
   if (!isTerminalAnimationTheme(theme)) {
     const choices = TERMINAL_ANIMATION_THEMES.map(({ id }) => id).join(", ");
     throw new Error(`Terminal animation must be one of: ${choices}`);

package/src/version.mjs

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { operationError } from "./operation-error.mjs";
 
-const GITHUB_LATEST_RELEASE_URL = "https://api.github.com/repos/DaleXiao/codex-copilot-dx/releases/latest";
-const MAX_RELEASE_BYTES = 256 * 1024;
+const GITHUB_LATEST_RELEASE_URL = "https://github.com/DaleXiao/codex-copilot-dx/releases/latest";
 
 export function localPackageVersion() {
   const here = path.dirname(fileURLToPath(import.meta.url));
@@ -37,62 +37,39 @@ export function githubReleaseVersion(tag) {
   return match.slice(1).join(".");
 }
 
-async function readReleaseJson(response, signal) {
-  const reader = response.body?.getReader?.();
-  if (!reader) throw new Error("GitHub release response has no readable body");
-  const cancel = () => { void reader.cancel().catch(() => {}); };
-  signal.addEventListener("abort", cancel, { once: true });
-  const chunks = [];
-  let bytes = 0;
-  let complete = false;
-  try {
-    if (Number(response.headers?.get?.("content-length")) > MAX_RELEASE_BYTES) {
-      throw new Error("GitHub release response is too large");
-    }
-    while (!signal.aborted) {
-      const { done, value } = await reader.read();
-      if (done) {
-        complete = true;
-        break;
-      }
-      bytes += value.byteLength;
-      if (bytes > MAX_RELEASE_BYTES) throw new Error("GitHub release response is too large");
-      chunks.push(Buffer.from(value));
-    }
-    if (signal.aborted) throw new Error("GitHub release request timed out");
-    return JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
-  } finally {
-    signal.removeEventListener("abort", cancel);
-    if (!complete) cancel();
-    reader.releaseLock();
-  }
-}
-
-export async function fetchLatestRelease({ fetchImpl = fetch, timeoutMs = 2000 } = {}) {
+export async function lookupLatestRelease({ fetchImpl = fetch, timeoutMs = 2000 } = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const resp = await fetchImpl(GITHUB_LATEST_RELEASE_URL, {
-      headers: { Accept: "application/vnd.github+json", "User-Agent": "codex-copilot-dx" },
-      redirect: "error",
+      headers: { Accept: "text/html", "User-Agent": "codex-copilot-dx" },
+      redirect: "manual",
       signal: controller.signal,
     });
-    if (!resp.ok) {
-      void resp.body?.cancel?.().catch(() => {});
-      return null;
+    void resp.body?.cancel?.().catch(() => {});
+    if ([403, 429].includes(resp.status)) throw operationError("github_rate_limit", `GitHub release lookup was refused (HTTP ${resp.status}); retry later. No update was installed.`, { status: resp.status });
+    if (![301, 302, 303, 307, 308].includes(resp.status)) throw operationError("github_http_error", `GitHub release lookup returned HTTP ${resp.status}; no stable release redirect was received. No update was installed.`, { status: resp.status });
+    let url;
+    try { url = new URL(resp.headers.get("location"), GITHUB_LATEST_RELEASE_URL); } catch {}
+    const match = url?.pathname.match(/^\/DaleXiao\/codex-copilot-dx\/releases\/tag\/([^/]+)$/i);
+    const tagName = match?.[1], version = githubReleaseVersion(tagName);
+    if (!url || url.origin !== "https://github.com" || url.username || url.password || url.search || url.hash || !version) {
+      throw operationError("github_invalid_redirect", "GitHub did not return a valid stable release tag for this repository. No update was installed.");
     }
-    const data = await readReleaseJson(resp, controller.signal);
-    const version = githubReleaseVersion(data?.tag_name);
-    return version && data.draft === false && data.prerelease === false
-      ? { version, tagName: data.tag_name }
-      : null;
-  } catch {
-    return null;
+    return { version, tagName };
+  } catch (error) {
+    if (error.code?.startsWith("github_")) throw error;
+    if (controller.signal.aborted) throw operationError("github_timeout", "GitHub release lookup timed out. No update was installed.");
+    throw operationError(error.cause?.code || "github_network_error", "Could not connect to the GitHub release page. Check your network or proxy. No update was installed.");
   } finally {
     clearTimeout(timer);
   }
 }
 
+export async function fetchLatestRelease(options = {}) {
+  try { return await lookupLatestRelease(options); } catch { return null; }
+}
+
 export async function fetchLatestVersion(options) {
   return (await fetchLatestRelease(options))?.version || null;
 }