codex-copilot-dx 0.9.23 → 0.9.24

package/src/native-prediction-overlay.mjs

@@ -0,0 +1,92 @@
+export const NATIVE_PREDICTION_GATE = "4290031608";
+
+const LOCAL_PREDICTION_CONFIG = Object.freeze({
+  is_enabled: true,
+  prompt: 'Predict one useful next message the user may send, based on the conversation. Write from the user\'s perspective and use the user\'s language. Do not answer the message, call tools, or invent new requests, consent, or permission. Prefer a short, natural follow-up. If no useful follow-up is apparent, use an empty string. Return only a JSON object with exactly one key: {"suggestion":"the predicted user message"}.',
+  prompt_version: "ccdx-native-prediction-v1",
+  prediction_reasoning_effort: "low",
+});
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function parseBody(body) {
+  if (typeof body !== "string" && !Buffer.isBuffer(body)) return null;
+  try { return JSON.parse(body.toString()); } catch { return null; }
+}
+
+function encodeBody(value, original) {
+  const text = JSON.stringify(value);
+  return Buffer.isBuffer(original) ? Buffer.from(text) : text;
+}
+
+export function classifyNativePredictionPath({ hostname, pathname } = {}) {
+  const host = typeof hostname === "string" ? hostname.toLowerCase() : "";
+  if (host === "chatgpt.com") {
+    if (pathname === "/backend-api/wham/statsig/bootstrap") return "bootstrap";
+    if (pathname === "/backend-api/wham/predictions/config") return "config";
+  }
+  if (host === "ab.chatgpt.com" && pathname === "/v1/initialize") return "refresh";
+  return null;
+}
+
+function enablePredictionGate(payload) {
+  if (!isObject(payload) || (payload.response_mode === "live_overlay" ? payload.has_updates === false : payload.has_updates !== true) ||
+      (payload.is_delta !== undefined && payload.is_delta !== false) ||
+      (payload.response_mode !== undefined && !["full", "live_overlay"].includes(payload.response_mode)) ||
+      !isObject(payload.feature_gates)) return false;
+  // Statsig V1 first resolves the literal name, then its djb2 lookup key.
+  let hash = 0;
+  for (const char of NATIVE_PREDICTION_GATE) hash = ((hash << 5) - hash + char.charCodeAt(0)) | 0;
+  const hashedKey = String(hash >>> 0);
+  const key = Object.hasOwn(payload.feature_gates, NATIVE_PREDICTION_GATE) ? NATIVE_PREDICTION_GATE
+    : Object.hasOwn(payload.feature_gates, hashedKey) ? hashedKey : NATIVE_PREDICTION_GATE;
+  const gate = payload.feature_gates[key];
+  if (gate !== undefined && (!isObject(gate) || typeof gate.value !== "boolean" || gate.value === true)) return false;
+  if (payload.response_mode === "live_overlay" && !Array.isArray(payload.live_entity_names?.feature_gates)) return false;
+  if (gate) gate.value = true;
+  else payload.feature_gates[key] = { name: key, value: true, rule_id: "ccdx-local-compatibility", secondary_exposures: [] };
+  if (payload.response_mode === "live_overlay" && !payload.live_entity_names.feature_gates.includes(key)) {
+    payload.live_entity_names.feature_gates.push(key);
+  }
+  return true;
+}
+
+// No-op results retain the original bytes; callers own HTTP headers and decoding.
+export function applyNativePredictionOverlay({ hostname, pathname, statusCode, body, enabled = false } = {}) {
+  const kind = classifyNativePredictionPath({ hostname, pathname });
+  const result = { body, statusCode, changed: false, official: false, kind };
+  if (!enabled || !kind) return result;
+  if (kind === "config" && statusCode === 404) {
+    return { ...result, statusCode: 200, body: encodeBody(LOCAL_PREDICTION_CONFIG, body), changed: true };
+  }
+  if (statusCode !== 200) return result;
+  const parsed = parseBody(body);
+  if (!isObject(parsed)) return result;
+  if (kind === "config") {
+    if (parsed.is_enabled === true) return { ...result, official: true };
+    if (parsed.is_enabled !== false || typeof parsed.prompt !== "string" || !parsed.prompt.trim()) return result;
+    parsed.is_enabled = true;
+  } else if (kind === "bootstrap") {
+    const stringPayload = typeof parsed.statsigPayload === "string";
+    const payload = stringPayload ? parseBody(parsed.statsigPayload) : parsed.statsigPayload;
+    if (!enablePredictionGate(payload)) return result;
+    if (stringPayload) parsed.statsigPayload = JSON.stringify(payload);
+  } else if (!enablePredictionGate(parsed)) return result;
+  return { ...result, body: encodeBody(parsed, body), changed: true };
+}
+
+// Overlaying a delta would invalidate its checksum. Ask for a full response instead.
+export function normalizeStatsigRequest({ hostname, pathname, body, enabled = false } = {}) {
+  const result = { body, changed: false };
+  if (!enabled || classifyNativePredictionPath({ hostname, pathname }) !== "refresh") return result;
+  const parsed = parseBody(body);
+  if (!isObject(parsed) || !isObject(parsed.user) ||
+      (parsed.responseMode !== undefined && !["full", "live_overlay"].includes(parsed.responseMode))) return result;
+  if (parsed.deltasResponseRequested === false && parsed.full_checksum === null && parsed.sinceTime === 0) return result;
+  parsed.deltasResponseRequested = false;
+  parsed.full_checksum = null;
+  parsed.sinceTime = 0;
+  return { body: encodeBody(parsed, body), changed: true };
+}

package/src/native-prediction-profile.mjs

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash, X509Certificate, createPrivateKey, createPublicKey } from "node:crypto";
+import { atomicWriteFileSync } from "./atomic-file.mjs";
+import { userSettingsPath } from "./user-settings.mjs";
+
+export function predictionPaths({ env = process.env, home = os.homedir() } = {}) {
+  const directory = path.join(path.dirname(userSettingsPath({ env, home })), "native-prediction");
+  const profile = env.CODEX_ELECTRON_USER_DATA_PATH?.trim()
+    || path.join(home, "Library", "Application Support", "Codex");
+  return { directory, settings: path.join(directory, "settings.json"), profile,
+    store: path.join(profile, "Default", "ServerCertificate") };
+}
+
+export function readPredictionSettings(options = {}) {
+  const { settings } = predictionPaths(options);
+  try {
+    const value = JSON.parse(fs.readFileSync(settings, "utf8"));
+    if (value?.version !== 1 || typeof value.enabled !== "boolean") throw new Error();
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT") return { version: 1, enabled: false };
+    throw new Error("Native prediction settings are invalid; no settings were changed");
+  }
+}
+
+export function writePredictionSettings(value, options = {}) {
+  atomicWriteFileSync(predictionPaths(options).settings, JSON.stringify(value, null, 2) + "\n", { preserveMode: false });
+}
+
+export function assertPredictionProxyCompatible({ env = process.env, systemProxy = "" } = {}) {
+  if (["HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY", "https_proxy", "http_proxy", "all_proxy", "CODEX_API_BASE_URL"]
+    .some((key) => env[key]?.trim())
+    || /(?:HTTPEnable|HTTPSEnable|SOCKSEnable|ProxyAutoConfigEnable|ProxyAutoDiscoveryEnable)\s*:\s*1/.test(systemProxy)) {
+    throw new Error("Native prediction setup skipped: an existing proxy or API route is configured; it was not replaced");
+  }
+}
+
+export function assertCodexClosed({ exec = execFileSync } = {}) {
+  for (const name of ["ChatGPT", "Codex"]) {
+    try {
+      exec("/usr/bin/pgrep", ["-x", name], { stdio: "pipe", timeout: 2000 });
+    } catch (error) {
+      if (error.status === 1) continue;
+      throw new Error("Could not check whether Codex is closed; prediction setup was skipped");
+    }
+    throw new Error("Quit Codex App before changing native prediction setup; no running App will be stopped");
+  }
+}
+
+export function installedPredictionApp({ exec = execFileSync } = {}) {
+  for (const app of ["/Applications/ChatGPT.app", "/Applications/Codex.app"]) {
+    const archive = path.join(app, "Contents", "Resources", "app.asar");
+    if (!fs.existsSync(archive)) continue;
+    // Check only during explicit setup; startup uses the cheap identity check.
+    const fd = fs.openSync(archive, "r");
+    try {
+      const prefix = Buffer.alloc(16); fs.readSync(fd, prefix, 0, 16, 0);
+      const headerSize = prefix.readUInt32LE(12);
+      if (headerSize > 32 * 1024 * 1024) continue;
+      const header = Buffer.alloc(headerSize); fs.readSync(fd, header, 0, header.length, 16);
+      const files = JSON.parse(header).files?.[".vite"]?.files?.build?.files;
+      const entry = Object.entries(files || {}).find(([name]) => /^main-[\w-]+\.js$/.test(name))?.[1];
+      if (!entry || entry.size > 32 * 1024 * 1024 || entry.unpacked) continue;
+      const bytes = Buffer.alloc(entry.size);
+      fs.readSync(fd, bytes, 0, bytes.length, 8 + prefix.readUInt32LE(4) + Number(entry.offset));
+      const source = bytes.toString();
+      if (!["/wham/predictions/config", "experimentalPredictionMode"].every((value) => source.includes(value))) continue;
+      const renderer = Object.entries(JSON.parse(header).files?.webview?.files?.assets?.files || {})
+        .find(([name]) => /^general-settings-[\w-]+\.js$/.test(name))?.[1];
+      if (!renderer || renderer.unpacked || renderer.size > 4 * 1024 * 1024) continue;
+      const rendererBytes = Buffer.alloc(renderer.size);
+      fs.readSync(fd, rendererBytes, 0, rendererBytes.length, 8 + prefix.readUInt32LE(4) + Number(renderer.offset));
+      if (!rendererBytes.includes(Buffer.from("4290031608"))) continue;
+      exec("/usr/bin/codesign", ["--verify", "--deep", "--strict", app], { stdio: "pipe", timeout: 15_000 });
+      const stat = fs.statSync(archive);
+      return { app, archive, size: stat.size, mtimeMs: stat.mtimeMs };
+    } finally { fs.closeSync(fd); }
+  }
+  throw new Error("This Codex App does not expose the verified native prediction protocol; setup was skipped");
+}
+
+export function predictionAppMatches(app) {
+  try { const stat = fs.statSync(app.archive); return stat.size === app.size && stat.mtimeMs === app.mtimeMs; }
+  catch { return false; }
+}
+
+function privateDirectory(directory) {
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const stat = fs.lstatSync(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077)) {
+    throw new Error("Prediction key directory must be private and must not be a symlink");
+  }
+}
+
+export function readPredictionCertificate(directory, { allowExpired = false } = {}) {
+  const cert = fs.readFileSync(path.join(directory, "bridge.pem"));
+  const ca = new X509Certificate(fs.readFileSync(path.join(directory, "ca.pem")));
+  const keyFile = path.join(directory, "bridge.key");
+  const info = fs.lstatSync(keyFile);
+  if (!info.isFile() || info.isSymbolicLink() || (info.mode & 0o077)) throw new Error("Prediction key is not private");
+  const key = fs.readFileSync(keyFile);
+  const x509 = new X509Certificate(cert);
+  const publicKey = createPublicKey(createPrivateKey(key)).export({ type: "spki", format: "der" });
+  if (!x509.publicKey.export({ type: "spki", format: "der" }).equals(publicKey)
+    || (!allowExpired && Date.parse(x509.validTo) <= Date.now()) || !x509.checkHost("chatgpt.com") || !x509.checkHost("ab.chatgpt.com")
+    || !x509.verify(ca.publicKey) || !ca.ca || x509.ca) {
+    throw new Error("Prediction certificate needs renewal; quit Codex and run ccdx prediction on");
+  }
+  return { cert, key, ca: ca.toString(), hash: createHash("sha256").update(ca.raw).digest("hex").toUpperCase(), der: ca.raw };
+}
+
+export function createPredictionCertificate(directory, { exec = execFileSync } = {}) {
+  privateDirectory(directory);
+  const temporary = fs.mkdtempSync(path.join(directory, "certificate-"));
+  try {
+    const config = `[req]\nprompt=no\ndistinguished_name=dn\nx509_extensions=ext\n[dn]\nCN=CCDX native prediction local bridge\n[ext]\nbasicConstraints=critical,CA:TRUE,pathlen:0\nkeyUsage=critical,keyCertSign,digitalSignature\nextendedKeyUsage=serverAuth\nsubjectAltName=DNS:chatgpt.com,DNS:ab.chatgpt.com\nnameConstraints=critical,permitted;DNS:chatgpt.com\n`;
+    const configFile = path.join(temporary, "openssl.cnf");
+    atomicWriteFileSync(configFile, config);
+    const certFile = path.join(temporary, "cert.pem"), keyFile = path.join(temporary, "key.pem");
+    const caFile = path.join(temporary, "ca.pem"), caKey = path.join(temporary, "ca.key");
+    const run = (args) => exec("/usr/bin/openssl", args, { stdio: "pipe", timeout: 15_000 });
+    run(["req", "-x509", "-newkey", "rsa:2048", "-nodes", "-days", "90", "-config", configFile, "-out", caFile, "-keyout", caKey]);
+    const csr = path.join(temporary, "leaf.csr"), extensions = path.join(temporary, "leaf.cnf");
+    atomicWriteFileSync(extensions, "basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\nsubjectAltName=DNS:chatgpt.com,DNS:ab.chatgpt.com\n");
+    run(["req", "-newkey", "rsa:2048", "-nodes", "-keyout", keyFile, "-out", csr, "-subj", "/CN=CCDX local prediction bridge"]);
+    run(["x509", "-req", "-in", csr, "-CA", caFile, "-CAkey", caKey, "-CAcreateserial", "-days", "90", "-extfile", extensions, "-out", certFile]);
+    atomicWriteFileSync(path.join(directory, "bridge.key"), fs.readFileSync(keyFile), { preserveMode: false });
+    atomicWriteFileSync(path.join(directory, "bridge.pem"), fs.readFileSync(certFile), { preserveMode: false });
+    atomicWriteFileSync(path.join(directory, "ca.pem"), fs.readFileSync(caFile), { preserveMode: false });
+    return readPredictionCertificate(directory);
+  } finally { fs.rmSync(temporary, { recursive: true, force: true }); }
+}
+
+// Chromium certificate metadata: trusted anchor, exact DNS constraints. This
+// private record is scoped to one App profile; no system keychain is changed.
+export function predictionTrustMetadata() {
+  const names = ["chatgpt.com", "ab.chatgpt.com"].map((name) => Buffer.concat([Buffer.from([10, Buffer.byteLength(name)]), Buffer.from(name)]));
+  const constraints = Buffer.concat(names);
+  return Buffer.concat([Buffer.from([10, 2, 8, 3, 18, constraints.length]), constraints]);
+}
+
+export async function updatePredictionTrust(store, certificate, { remove = false, priorHash = null } = {}) {
+  if (remove && !fs.existsSync(store)) return false;
+  if (fs.existsSync(store) && !fs.lstatSync(store).isFile()) throw new Error("Unexpected certificate-store file; skipped");
+  fs.mkdirSync(path.dirname(store), { recursive: true, mode: 0o700 });
+  const { DatabaseSync } = await import("node:sqlite");
+  const db = new DatabaseSync(store);
+  try {
+    db.exec("PRAGMA busy_timeout=1000; BEGIN IMMEDIATE");
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((item) => item.name);
+    if (!tables.length && !remove) {
+      db.exec("CREATE TABLE meta(key LONGVARCHAR NOT NULL UNIQUE PRIMARY KEY,value LONGVARCHAR); CREATE TABLE certificates(sha256hash_hex TEXT PRIMARY KEY,der_cert BLOB NOT NULL,trust_settings BLOB NOT NULL)");
+      db.prepare("INSERT INTO meta VALUES(?,?)").run("version", "1");
+      db.prepare("INSERT INTO meta VALUES(?,?)").run("last_compatible_version", "1");
+    }
+    const meta = db.prepare("SELECT value FROM meta WHERE key='version'").get();
+    const columns = db.prepare("PRAGMA table_info(certificates)").all().map((item) => item.name);
+    if (String(meta?.value) !== "1" || columns.join(",") !== "sha256hash_hex,der_cert,trust_settings") throw new Error("Unknown certificate-store schema; skipped");
+    const metadata = predictionTrustMetadata();
+    const existing = db.prepare("SELECT der_cert,trust_settings FROM certificates WHERE sha256hash_hex=?").get(certificate.hash);
+    if (existing && (!Buffer.from(existing.der_cert).equals(certificate.der) || !Buffer.from(existing.trust_settings).equals(metadata))) throw new Error("Prediction trust was modified; it was preserved");
+    if (remove) {
+      if (existing) db.prepare("DELETE FROM certificates WHERE sha256hash_hex=?").run(certificate.hash);
+    } else {
+      if (priorHash && priorHash !== certificate.hash) {
+        const previous = db.prepare("SELECT trust_settings FROM certificates WHERE sha256hash_hex=?").get(priorHash);
+        if (previous && !Buffer.from(previous.trust_settings).equals(metadata)) throw new Error("Previous prediction trust was modified; it was preserved");
+        db.prepare("DELETE FROM certificates WHERE sha256hash_hex=?").run(priorHash);
+      }
+      if (!existing) db.prepare("INSERT INTO certificates VALUES(?,?,?)").run(certificate.hash, certificate.der, metadata);
+    }
+    db.exec("COMMIT");
+    return remove ? Boolean(existing) : !existing;
+  } catch (error) {
+    try { db.exec("ROLLBACK"); } catch {}
+    throw error;
+  } finally { db.close(); }
+}

package/src/native-prediction-transport.mjs

@@ -0,0 +1,242 @@
+import http from "node:http";
+import https from "node:https";
+import { promisify } from "node:util";
+import { gunzip, inflate, brotliDecompress } from "node:zlib";
+
+export const PREDICTION_HOSTS = Object.freeze(["chatgpt.com", "ab.chatgpt.com"]);
+const CONFIG_LIMIT = 16 * 1024 * 1024;
+const REQUEST_LIMIT = 512 * 1024;
+const decoders = { gzip: promisify(gunzip), deflate: promisify(inflate), br: promisify(brotliDecompress) };
+
+export function predictionRoute(host, pathname) {
+  if (host === "chatgpt.com" && pathname === "/backend-api/wham/statsig/bootstrap") return "bootstrap";
+  if (host === "chatgpt.com" && pathname === "/backend-api/wham/predictions/config") return "prediction";
+  if (host === "ab.chatgpt.com" && pathname === "/v1/initialize") return "refresh";
+  return null;
+}
+
+export function predictionPac(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid prediction proxy port");
+  return `function FindProxyForURL(url, host) { if (url.indexOf('https:') === 0 && (host === 'chatgpt.com' || host === 'ab.chatgpt.com')) return 'PROXY 127.0.0.1:${port}; DIRECT'; return 'DIRECT'; }\n`;
+}
+
+function cleanHeaders(headers) {
+  const result = { ...headers };
+  for (const name of String(headers.connection || "").split(",")) delete result[name.trim().toLowerCase()];
+  for (const name of ["connection", "proxy-authorization", "proxy-authenticate", "keep-alive", "te", "trailer", "transfer-encoding", "upgrade"]) delete result[name];
+  return result;
+}
+
+function changedHeaders(headers, length) {
+  const result = cleanHeaders(headers);
+  for (const name of ["content-encoding", "etag", "content-md5", "digest", "content-digest"]) delete result[name];
+  result["content-length"] = String(length);
+  result["cache-control"] = "no-store";
+  return result;
+}
+
+async function decode(bytes, encoding, limit) {
+  if (!encoding || encoding === "identity") return bytes;
+  if (!decoders[encoding]) throw new Error("Unsupported configuration encoding");
+  return decoders[encoding](bytes, { maxOutputLength: limit });
+}
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.removeListener("error", reject);
+      resolve(server.address().port);
+    });
+  });
+}
+
+// Only selected configuration bodies are buffered. Other traffic is streamed,
+// without retries, redirects, credential storage or request/response logging.
+export async function startPredictionTransport({
+  key, cert, overlay, normalizeRequest = (value) => value,
+  enabled = () => true, requestImpl = https.request,
+  timeoutMs = 30_000, maxConnections = 128,
+}) {
+  const sockets = new Set();
+  const upstreams = new Set();
+  let closing = false;
+  const gateway = https.createServer({ key, cert, minVersion: "TLSv1.2" }, (req, res) => {
+    let target;
+    try {
+      target = new URL(req.url, `https://${req.headers.host}`);
+      if (!PREDICTION_HOSTS.includes(target.hostname) || target.port || target.protocol !== "https:"
+        || target.username || target.password || !req.url.startsWith("/") || req.url.startsWith("//")
+        || req.headers.host !== target.hostname || req.socket.servername !== target.hostname) throw new Error("Invalid target");
+    } catch {
+      res.writeHead(403); res.end(); return;
+    }
+    const route = predictionRoute(target.hostname, target.pathname);
+    const headers = cleanHeaders(req.headers);
+    // No decoding/re-encoding on pass-through paths.
+    if (route && enabled()) headers["accept-encoding"] = "identity";
+    let upstream;
+    const fail = () => {
+      if (!res.headersSent) { res.writeHead(502); res.end(); } else res.destroy();
+    };
+    const send = (body, streamRemainder = false) => {
+      if (res.destroyed || closing) return;
+      upstream = requestImpl({
+        protocol: "https:", hostname: target.hostname, port: 443,
+        servername: target.hostname, method: req.method,
+        path: req.url, headers,
+        rejectUnauthorized: true,
+      }, (reply) => {
+        const pass = () => {
+          res.writeHead(reply.statusCode, cleanHeaders(reply.headers));
+          reply.pipe(res);
+        };
+        reply.on("error", fail);
+        // Error and non-JSON responses are forwarded as received. The overlay
+        // decides whether the narrowly allowed missing-config response applies.
+        const mediaType = String(reply.headers["content-type"] || "").split(";", 1)[0].trim();
+        if (!route || !enabled() || mediaType !== "application/json") { pass(); return; }
+        let size = 0;
+        const parts = [];
+        let streaming = false;
+        reply.on("data", (chunk) => {
+          if (streaming) return;
+          parts.push(chunk); size += chunk.length;
+          if (size > CONFIG_LIMIT) {
+            streaming = true;
+            res.writeHead(reply.statusCode, cleanHeaders(reply.headers));
+            reply.pause();
+            const buffered = Buffer.concat(parts); parts.length = 0;
+            if (res.write(buffered)) reply.pipe(res);
+            else res.once("drain", () => reply.pipe(res));
+          }
+        });
+        reply.on("end", () => void (async () => {
+          if (streaming || res.destroyed) return;
+          const original = Buffer.concat(parts);
+          let next = null;
+          try {
+            const decoded = await decode(original, reply.headers["content-encoding"], CONFIG_LIMIT);
+            if (decoded.length <= CONFIG_LIMIT) next = overlay({
+              route, host: target.hostname, pathname: target.pathname,
+              status: reply.statusCode, body: decoded.toString("utf8"),
+              enabled: enabled(),
+            });
+          } catch { /* Preserve unexpected upstream payloads byte-for-byte. */ }
+          if (next?.body !== undefined && (next.body !== original.toString("utf8") || next.status !== reply.statusCode)) {
+            const bytes = Buffer.from(next.body);
+            res.writeHead(next.status ?? reply.statusCode, changedHeaders(reply.headers, bytes.length));
+            res.end(bytes);
+          } else {
+            res.writeHead(reply.statusCode, cleanHeaders(reply.headers)); res.end(original);
+          }
+        })().catch(fail));
+      });
+      upstreams.add(upstream);
+      upstream.once("close", () => upstreams.delete(upstream));
+      if (route && enabled()) upstream.setTimeout(timeoutMs, () => upstream.destroy(new Error("Upstream timeout")));
+      upstream.on("error", fail);
+      if (streamRemainder) {
+        if (upstream.write(body)) req.pipe(upstream);
+        else upstream.once("drain", () => req.pipe(upstream));
+      } else if (body !== undefined) upstream.end(body); else req.pipe(upstream);
+    };
+    req.on("aborted", () => upstream?.destroy());
+    req.on("error", () => upstream?.destroy());
+    res.on("close", () => { if (!res.writableFinished) upstream?.destroy(); });
+    if (route !== "refresh" || req.method !== "POST" || !enabled()) { send(); return; }
+    // Statsig deltas use a checksum of prior values. Ask for a complete response
+    // so the client never merges an upstream delta with locally changed values.
+    void (async () => {
+      const parts = []; let size = 0;
+      for await (const part of req.iterator({ destroyOnReturn: false })) {
+        size += part.length;
+        parts.push(part);
+        if (size > REQUEST_LIMIT) { send(Buffer.concat(parts), true); return; }
+      }
+      let body = Buffer.concat(parts);
+      try {
+        const decoded = await decode(body, headers["content-encoding"], REQUEST_LIMIT);
+        const encoded = target.searchParams.get("se") === "1";
+        const text = encoded ? Buffer.from(decoded.toString().split("").reverse().join(""), "base64").toString() : decoded.toString();
+        const parsed = JSON.parse(text);
+        const normalized = normalizeRequest(parsed);
+        if (normalized !== parsed) {
+          const json = JSON.stringify(normalized);
+          body = Buffer.from(encoded ? Buffer.from(json).toString("base64").split("").reverse().join("") : json);
+          delete headers["content-encoding"];
+          headers["content-length"] = String(body.length);
+        }
+      } catch { /* Unknown request encoding stays untouched. */ }
+      send(body);
+    })().catch(fail);
+  });
+  gateway.on("secureConnection", (socket) => socket.setTimeout(0));
+  gateway.on("upgrade", (req, socket, head) => {
+    const host = req.headers.host;
+    if (!PREDICTION_HOSTS.includes(host) || req.socket.servername !== host
+      || !req.url.startsWith("/") || req.url.startsWith("//")) { socket.destroy(); return; }
+    const upstream = requestImpl({
+      protocol: "https:", hostname: host, port: 443, servername: host,
+      method: req.method, path: req.url, rejectUnauthorized: true,
+      headers: { ...cleanHeaders(req.headers), connection: "Upgrade", upgrade: req.headers.upgrade },
+    });
+    upstreams.add(upstream);
+    upstream.on("error", () => socket.destroy());
+    upstream.on("response", (reply) => {
+      const headers = Object.entries(cleanHeaders(reply.headers)).flatMap(([name, values]) =>
+        (Array.isArray(values) ? values : [values]).map((value) => `${name}: ${value}`));
+      socket.write(`HTTP/1.1 ${reply.statusCode} ${reply.statusMessage}\r\n${headers.join("\r\n")}\r\nConnection: close\r\n\r\n`);
+      reply.on("error", () => socket.destroy()); reply.pipe(socket);
+    });
+    upstream.on("upgrade", (reply, peer, peerHead) => {
+      upstreams.delete(upstream);
+      sockets.add(peer); peer.once("close", () => sockets.delete(peer));
+      const headers = Object.entries(reply.headers).flatMap(([name, values]) =>
+        (Array.isArray(values) ? values : [values]).map((value) => `${name}: ${value}`));
+      socket.write(`HTTP/1.1 ${reply.statusCode} ${reply.statusMessage}\r\n${headers.join("\r\n")}\r\n\r\n`);
+      if (peerHead.length) socket.write(peerHead);
+      if (head.length) peer.write(head);
+      socket.on("error", () => peer.destroy()); peer.on("error", () => socket.destroy());
+      socket.once("close", () => peer.destroy()); peer.once("close", () => socket.destroy());
+      socket.pipe(peer); peer.pipe(socket);
+    });
+    socket.once("close", () => { upstreams.delete(upstream); upstream.destroy(); });
+    upstream.end();
+  });
+  gateway.on("tlsClientError", (_error, socket) => socket.destroy());
+  gateway.on("clientError", (_error, socket) => socket.destroy());
+  const proxy = http.createServer((req, res) => {
+    if (req.method === "GET" && req.url === "/proxy.pac" && !req.headers.origin
+      && ["127.0.0.1", "localhost"].includes(String(req.headers.host || "").split(":")[0])) {
+      res.writeHead(200, { "Content-Type": "application/x-ns-proxy-autoconfig", "Cache-Control": "no-store" });
+      res.end(predictionPac(proxy.address().port)); return;
+    }
+    res.writeHead(403); res.end();
+  });
+  proxy.on("connection", (socket) => {
+    if (closing || sockets.size >= maxConnections) { socket.destroy(); return; }
+    sockets.add(socket); socket.once("close", () => sockets.delete(socket));
+  });
+  proxy.on("connect", (req, socket, head) => {
+    if (closing || !PREDICTION_HOSTS.some((host) => req.url === `${host}:443`) || req.headers.origin) {
+      socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n"); return;
+    }
+    socket.setTimeout(timeoutMs, () => socket.destroy());
+    socket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+    if (head.length) socket.unshift(head);
+    gateway.emit("connection", socket);
+  });
+  proxy.on("clientError", (_error, socket) => socket.destroy());
+  const port = await listen(proxy);
+  return {
+    port, pacUrl: `http://127.0.0.1:${port}/proxy.pac`,
+    async close() {
+      closing = true;
+      for (const upstream of upstreams) upstream.destroy();
+      for (const socket of sockets) socket.destroy();
+      await new Promise((resolve) => proxy.close(resolve));
+      gateway.close();
+    },
+  };
+}