@yina-npm/openrouterx 0.4.55 → 0.4.71

package/app/src/mitm/server.js

@@ -1,22 +1,17 @@
 const https = require("https");
+const http2 = require("http2");
+const tls = require("tls");
 const fs = require("fs");
 const path = require("path");
 const dns = require("dns");
-const os = require("os");
-const zlib = require("zlib");
 const { promisify } = require("util");
 const { execSync } = require("child_process");
 const { log, err, dumpRequest, createResponseDumper, clearDumpDir } = require("./logger");
-const { IS_DEV, TARGET_HOSTS, URL_PATTERNS, MODEL_SYNONYMS, MODEL_PATTERNS, getToolForHost } = require("./config");
-const { pickReachableAddress, createLocalAliasResolutionError } = require("./upstreamResolver");
-const {
-  createLocalAntigravityLoadCodeAssistPayload,
-  createLocalAntigravityOnboardUserPayload,
-} = require("./antigravityBootstrap");
-const { buildAntigravityAvailableModelsResponse } = require("./antigravityModels");
+const { IS_DEV, LSOF_BIN, TARGET_HOSTS, URL_PATTERNS, MODEL_SYNONYMS, MODEL_PATTERNS, MODEL_NO_MAP, getToolForHost } = require("./config");
 const { DATA_DIR, MITM_DIR } = require("./paths");
 const { getCertForDomain } = require("./cert/generate");
 const { getMitmAlias } = require("./dbReader");
+const { applyAntigravityIdeVersionOverride } = require("./antigravityIdeVersion");
 const LOCAL_PORT = 443;
 const IS_WIN = process.platform === "win32";
 const ENABLE_FILE_LOG = IS_DEV;
@@ -29,7 +24,6 @@ const INTERNAL_REQUEST_HEADER = { name: "x-request-source", value: "local" };
 // daily-cloudcode-pa (dev endpoint) accepts same body+token. Same trick as open-sse.
 const HOST_REWRITE = {
   "cloudcode-pa.googleapis.com": "daily-cloudcode-pa.googleapis.com",
-  "daily-cloudcode-pa.sandbox.googleapis.com": "daily-cloudcode-pa.googleapis.com",
 };
 
 const handlers = {
@@ -37,7 +31,6 @@ const handlers = {
   copilot: require("./handlers/copilot"),
   kiro: require("./handlers/kiro"),
   cursor: require("./handlers/cursor"),
-  openrouter: require("./handlers/openrouter"),
 };
 
 // ── SSL / SNI ─────────────────────────────────────────────────
@@ -77,82 +70,18 @@ try {
 
 const cachedTargetIPs = {};
 const CACHE_TTL_MS = 5 * 60 * 1000;
-const PUBLIC_DNS_SERVERS = ["8.8.8.8", "1.1.1.1"];
-const DNS_QUERY_TIMEOUT_MS = 1500;
-const GOOGLE_FRONTEND_FALLBACK_HOSTS = ["storage.googleapis.com", "www.gstatic.com"];
-const GOOGLE_HOST_SUFFIXES = [".googleapis.com", ".google.com", ".gstatic.com"];
-const PASSTHROUGH_CONNECT_TIMEOUT_MS = 15000;
-
-function getLocalIPv4Aliases() {
-  const addresses = [];
-  for (const iface of Object.values(os.networkInterfaces())) {
-    for (const address of iface || []) {
-      if (address.family === "IPv4" || address.family === 4) addresses.push(address.address);
-    }
-  }
-  if (process.platform !== "darwin") return [...new Set(addresses)];
-  try {
-    const out = execSync("ifconfig lo0", { encoding: "utf8", windowsHide: true });
-    addresses.push(...[...out.matchAll(/^\s+inet\s+(\d+\.\d+\.\d+\.\d+)\s+/gm)].map((m) => m[1]));
-  } catch {
-    // Best effort; networkInterfaces still covers normal local addresses.
-  }
-  return [...new Set(addresses)];
-}
 
-async function resolveTargetIP(hostname, options = {}) {
-  const avoidAddresses = options.avoidAddresses || [];
-  const force = options.force === true || avoidAddresses.length > 0;
+async function resolveTargetIP(hostname) {
   const cached = cachedTargetIPs[hostname];
-  const localAliases = getLocalIPv4Aliases();
-  if (!force && cached && Date.now() - cached.ts < CACHE_TTL_MS) {
-    const ip = pickReachableAddress([cached.ip], { localAddresses: localAliases });
-    if (ip) return ip;
-  }
-  const addresses = await resolveIPv4Candidates(hostname);
-  let ip = pickReachableAddress(addresses, { localAddresses: localAliases, avoidAddresses });
-  if (!ip && isGoogleHost(hostname)) {
-    const fallbackAddresses = (await Promise.all(
-      GOOGLE_FRONTEND_FALLBACK_HOSTS.map((host) => resolveIPv4Candidates(host).catch(() => []))
-    )).flat();
-    ip = pickReachableAddress(fallbackAddresses, { localAddresses: localAliases, avoidAddresses });
-    if (ip) log(`⏩ upstream fallback | ${hostname} via Google frontend ${ip}`);
-  }
-  if (!ip) throw createLocalAliasResolutionError(hostname, addresses, { localAddresses: localAliases, avoidAddresses });
-  cachedTargetIPs[hostname] = { ip, ts: Date.now() };
+  if (cached && Date.now() - cached.ts < CACHE_TTL_MS) return cached.ip;
+  const resolver = new dns.Resolver();
+  resolver.setServers(["8.8.8.8"]);
+  const resolve4 = promisify(resolver.resolve4.bind(resolver));
+  const addresses = await resolve4(hostname);
+  cachedTargetIPs[hostname] = { ip: addresses[0], ts: Date.now() };
   return cachedTargetIPs[hostname].ip;
 }
 
-function isGoogleHost(hostname) {
-  return GOOGLE_HOST_SUFFIXES.some((suffix) => hostname === suffix.slice(1) || hostname.endsWith(suffix));
-}
-
-async function resolveIPv4Candidates(hostname) {
-  const attempts = await Promise.all(PUBLIC_DNS_SERVERS.map(async (server) => {
-    const resolver = new dns.Resolver();
-    resolver.setServers([server]);
-    const resolve4 = promisify(resolver.resolve4.bind(resolver));
-    return withTimeout(resolve4(hostname), DNS_QUERY_TIMEOUT_MS).catch(() => []);
-  }));
-  const addresses = [...new Set(attempts.flat())];
-  if (addresses.length > 0) return addresses;
-
-  const lookup = promisify(dns.lookup);
-  const records = await lookup(hostname, { family: 4, all: true }).catch(() => []);
-  if (records.length === 0) throw new Error(`DNS resolve failed for ${hostname}`);
-  return [...new Set(records.map((record) => record.address))];
-}
-
-function withTimeout(promise, timeoutMs) {
-  let timeout;
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => {
-      timeout = setTimeout(() => reject(new Error("DNS query timed out")), timeoutMs);
-    }),
-  ]).finally(() => clearTimeout(timeout));
-}
-
 function collectBodyRaw(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
@@ -166,6 +95,10 @@ function collectBodyRaw(req) {
 function extractModel(url, body) {
   const urlMatch = url.match(/\/models\/([^/:]+)/);
   if (urlMatch) return urlMatch[1];
+  
+  // Skip parsing if body is binary (AWS EventStream, Protocol Buffers, etc.)
+  if (isBinaryData(body)) return null;
+  
   try {
     const parsed = JSON.parse(body.toString());
     if (parsed.conversationState) {
@@ -175,20 +108,38 @@ function extractModel(url, body) {
   } catch { return null; }
 }
 
+// Detect binary data vs JSON text
+function isBinaryData(buffer) {
+  if (!buffer || buffer.length === 0) return false;
+  // AWS EventStream signature: first 4 bytes = frame length (big-endian uint32)
+  // Check for non-printable chars in first 100 bytes (common in binary protocols)
+  const sample = buffer.slice(0, Math.min(100, buffer.length));
+  let nonPrintable = 0;
+  for (let i = 0; i < sample.length; i++) {
+    const byte = sample[i];
+    // Count non-ASCII printable chars (excluding whitespace)
+    if (byte < 0x20 && byte !== 0x09 && byte !== 0x0A && byte !== 0x0D) {
+      nonPrintable++;
+    }
+    if (byte > 0x7E) nonPrintable++;
+  }
+  // If >30% non-printable, treat as binary
+  return (nonPrintable / sample.length) > 0.3;
+}
+
 function getMappedModel(tool, model) {
   if (!model) return null;
   try {
-    const aliases = {
-      ...(MODEL_SYNONYMS?.[tool]?.__defaults || {}),
-      ...(getMitmAlias(tool) || {}),
-    };
-    // Normalize via synonym map (e.g., gemini-default → gemini-3-flash)
-    const lookup = MODEL_SYNONYMS?.[tool]?.[model] || model;
+    const aliases = getMitmAlias(tool);
+    if (!aliases) return null;
+    // Normalize via synonym map (e.g., public AG names -> backend model ids)
+    const normalizedModel = String(model).replace(/^models\//, "");
+    const lookup = MODEL_SYNONYMS?.[tool]?.[normalizedModel] || normalizedModel;
     if (aliases[lookup]) return aliases[lookup];
     // Prefix match fallback
     const prefixKey = Object.keys(aliases).find(k => k && aliases[k] && (lookup.startsWith(k) || k.startsWith(lookup)));
     if (prefixKey) return aliases[prefixKey];
-    // Pattern fallback: catches AG renamed variants (e.g. gemini-pro-agent → gemini-3.1-pro-high)
+    // Pattern fallback: catches AG renamed variants (e.g. deprecated pro IDs → gemini-pro-agent)
     const patterns = MODEL_PATTERNS?.[tool] || [];
     for (const { match, alias } of patterns) {
       if (match.test(lookup) && aliases[alias]) return aliases[alias];
@@ -197,220 +148,177 @@ function getMappedModel(tool, model) {
   } catch { return null; }
 }
 
-function respondJson(res, statusCode, payload) {
-  const body = JSON.stringify(payload);
-  res.writeHead(statusCode, {
-    "Content-Type": "application/json; charset=UTF-8",
-    "Content-Length": Buffer.byteLength(body),
-  });
-  res.end(body);
-}
-
-function shouldDumpRequest(req) {
-  if (process.env.OPENROUTERX_MITM_DUMP_ALL === "1") return true;
-  return !!getToolForHost(req.headers.host);
-}
-
-function handleLocalAntigravityBootstrap(req, res) {
-  if (req.url.includes(":fetchAvailableModels") && process.env.OPENROUTERX_AG_LOCAL_MODELS !== "0") {
-    const payload = buildAntigravityAvailableModelsResponse();
-    respondJson(res, 200, payload);
-    log(`🧩 bootstrap | antigravity | local fetchAvailableModels (${Object.keys(payload.models || {}).length} models)`);
-    return true;
-  }
-
-  // The language server refreshes this cache next to the model list. Upstream
-  // can reject the MITM-shaped request with INVALID_ARGUMENT, which then marks
-  // the whole background cache refresh as failed even when models were local.
-  if (req.url.includes(":fetchAdminControls")) {
-    respondJson(res, 200, { adminControls: [] });
-    log("🧩 bootstrap | antigravity | local fetchAdminControls");
-    return true;
-  }
-
-  const localAuthBootstrap = process.env.OPENROUTERX_AG_LOCAL_AUTH !== "0"
-    || process.env.OPENROUTERX_AG_MOCK_BOOTSTRAP === "1";
-
-  if (!localAuthBootstrap) return false;
-
-  if (req.url.includes(":loadCodeAssist")) {
-    respondJson(res, 200, createLocalAntigravityLoadCodeAssistPayload());
-    log("🧩 bootstrap | antigravity | local loadCodeAssist");
-    return true;
-  }
-
-  if (req.url.includes(":onboardUser")) {
-    respondJson(res, 200, createLocalAntigravityOnboardUserPayload());
-    log("🧩 bootstrap | antigravity | local onboardUser");
-    return true;
-  }
-
-  if (req.url.includes("/cascadeNuxes")) {
-    respondJson(res, 200, {
-      nuxes: [],
-      completedNuxes: [],
-    });
-    log("🧩 bootstrap | antigravity | local cascadeNuxes");
-    return true;
+/**
+ * Forward request to real upstream.
+ * Optional onResponse(rawBuffer) callback — if provided, tees the response
+ * so it's both forwarded to client AND passed to the callback for inspection.
+ * Also tees full stream into a dump file when ENABLE_FILE_LOG is on.
+ */
+async function passthrough(req, res, bodyBuffer, onResponse) {
+  const originalHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
+  // Only rewrite host for chat endpoints — daily-cloudcode-pa rejects auth/login requests
+  const isChatEndpoint = req.url.includes(":generateContent") || req.url.includes(":streamGenerateContent");
+  const targetHost = isChatEndpoint ? (HOST_REWRITE[originalHost] || originalHost) : originalHost;
+  const dumper = ENABLE_FILE_LOG ? createResponseDumper(req, "passthrough") : null;
+
+  const tool = getToolForHost(req.headers.host);
+  const versionOverride = tool === "antigravity"
+    ? applyAntigravityIdeVersionOverride(bodyBuffer, req.headers)
+    : { bodyBuffer, headers: req.headers };
+  const bodyForForwarding = versionOverride.bodyBuffer;
+  const headersForForwarding = { ...versionOverride.headers, host: targetHost };
+  if (bodyForForwarding !== bodyBuffer) {
+    headersForForwarding["content-length"] = String(bodyForForwarding.length);
   }
 
-  return false;
-}
-
-function decodeResponseBody(buf, headers = {}) {
-  if (!buf || buf.length === 0) return buf;
-  const enc = String(headers["content-encoding"] || headers["Content-Encoding"] || "").toLowerCase();
+  // ALPN negotiate: try HTTP/2 first (like browsers/mitmweb), fallback HTTP/1.1
   try {
-    if (enc.includes("gzip")) return zlib.gunzipSync(buf);
-    if (enc.includes("br")) return zlib.brotliDecompressSync(buf);
-    if (enc.includes("deflate")) return zlib.inflateSync(buf);
+    const proto = await negotiateAlpn(targetHost);
+    if (proto === "h2") {
+      return await passthroughHttp2(req, res, bodyForForwarding, headersForForwarding, targetHost, onResponse, dumper);
+    }
   } catch (e) {
-    err(`loadCodeAssist decode failed: ${e.message}`);
+    err(`[mitm] ALPN negotiate failed: ${e.message}, fallback to HTTP/1.1`);
   }
-  return buf;
-}
 
-function summarizeTier(tier) {
-  if (!tier || typeof tier !== "object") return String(tier || "unknown");
-  const id = tier.id || tier.tierId || tier.name || tier.displayName || "unknown";
-  const name = tier.displayName || tier.name || "";
-  const marker = tier.isDefault ? "*" : "";
-  return name && name !== id ? `${id}${marker}(${name})` : `${id}${marker}`;
+  return passthroughHttps(req, res, bodyForForwarding, headersForForwarding, targetHost, onResponse, dumper);
 }
 
-function summarizeIneligibleTier(tier) {
-  if (!tier || typeof tier !== "object") return String(tier || "unknown");
-  const id = tier.id || tier.tierId || tier.name || tier.displayName || "unknown";
-  const reason = tier.ineligibilityReason || tier.reason || tier.reasonCode || tier.code || "unknown";
-  const message = tier.message || tier.ineligibilityMessage || tier.description || "";
-  return message ? `${id}:${reason}:${message}` : `${id}:${reason}`;
+// ── ALPN negotiation cache ────────────────────────────────────
+const alpnCache = new Map(); // host → "h2" | "http/1.1"
+async function negotiateAlpn(host) {
+  if (alpnCache.has(host)) return alpnCache.get(host);
+  const ip = await resolveTargetIP(host);
+  return new Promise((resolve, reject) => {
+    const socket = tls.connect({
+      host: ip, port: 443, servername: host,
+      ALPNProtocols: ["h2", "http/1.1"], rejectUnauthorized: false,
+    }, () => {
+      const proto = socket.alpnProtocol || "http/1.1";
+      alpnCache.set(host, proto);
+      log(`🔗 [mitm] ALPN ${host} → ${proto}`);
+      socket.end();
+      resolve(proto);
+    });
+    socket.once("error", reject);
+    socket.setTimeout(5000, () => { socket.destroy(new Error("ALPN timeout")); });
+  });
 }
 
-function inspectAntigravityLoadCodeAssist(rawBuffer, headers) {
-  const text = decodeResponseBody(rawBuffer, headers).toString("utf8");
-  try {
-    const payload = JSON.parse(text);
-    const allowed = Array.isArray(payload.allowedTiers)
-      ? payload.allowedTiers.map(summarizeTier)
-      : [];
-    const ineligible = Array.isArray(payload.ineligibleTiers)
-      ? payload.ineligibleTiers.map(summarizeIneligibleTier)
-      : [];
-    const project = payload.cloudaicompanionProject || payload.cloudaicompanionProjectId || payload.project || "";
-    const validationUrl = /https?:\/\/\S+/i.test(text) ? "present" : "none";
-
-    log(
-      `🧩 loadCodeAssist MITM | status=passthrough | project=${project || "none"} | ` +
-      `allowed=${allowed.length ? allowed.join(", ") : "none"} | ` +
-      `ineligible=${ineligible.length ? ineligible.join(" | ") : "none"} | validationUrl=${validationUrl}`
-    );
-  } catch {
-    log(`🧩 loadCodeAssist MITM | status=passthrough | non-json response bytes=${rawBuffer.length}`);
+// HTTP/2 passthrough using node:http2 native
+async function passthroughHttp2(req, res, bodyBuffer, headers, targetHost, onResponse, dumper) {
+  const targetIP = await resolveTargetIP(targetHost);
+  // HTTP/2 pseudo-headers required; strip HTTP/1.1-only headers
+  const h2Headers = {};
+  for (const [k, v] of Object.entries(headers)) {
+    const lk = k.toLowerCase();
+    if (lk === "host" || lk === "connection" || lk === "keep-alive" ||
+        lk === "transfer-encoding" || lk === "upgrade" || lk === "proxy-connection") continue;
+    h2Headers[lk] = v;
   }
-}
-
-/**
- * Forward request to real upstream.
- * Optional onResponse(rawBuffer, headers) callback — if provided, tees the response
- * so it's both forwarded to client AND passed to the callback for inspection.
- * Optional transformResponse(rawBuffer, headers) callback — if provided, buffers
- * the full response, passes it to the callback, and sends the returned buffer
- * to the client instead of the original response.
- * Also tees full stream into a dump file when ENABLE_FILE_LOG is on.
- */
-async function passthrough(req, res, bodyBuffer, onResponse, transformResponse) {
-  const originalHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
-  const targetHost = HOST_REWRITE[originalHost] || originalHost;
-  const dumper = ENABLE_FILE_LOG && shouldDumpRequest(req) ? createResponseDumper(req, "passthrough") : null;
-  const writeResolveError = (e) => {
-    err(`Passthrough resolve error for ${targetHost}: ${e.code || e.message}`);
-    if (dumper) { dumper.writeChunk(`\n[ERROR] resolve ${targetHost}: ${e.message}\n`); dumper.end(); }
-    if (!res.headersSent) res.writeHead(502, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: { message: e.message || `DNS resolve failed for ${targetHost}`, type: "mitm_dns_error" } }));
-  };
-
-  const startForward = async (attempt = 0, avoidAddresses = []) => {
-    let targetIP;
-    try {
-      targetIP = await resolveTargetIP(targetHost, { force: attempt > 0, avoidAddresses });
-    } catch (e) {
-      writeResolveError(e);
-      return;
-    }
+  h2Headers[":method"] = req.method;
+  h2Headers[":path"] = req.url;
+  h2Headers[":scheme"] = "https";
+  h2Headers[":authority"] = targetHost;
+
+  return new Promise((resolve) => {
+    const client = http2.connect(`https://${targetHost}`, {
+      createConnection: () => tls.connect({
+        host: targetIP, port: 443, servername: targetHost,
+        ALPNProtocols: ["h2"], rejectUnauthorized: false,
+      }),
+    });
+    client.once("error", (e) => {
+      err(`[mitm] http2 client error: ${e.message}`);
+      if (dumper) { dumper.writeChunk(`\n[ERROR h2] ${e.message}\n`); dumper.end(); }
+      if (!res.headersSent) res.writeHead(502);
+      if (!res.writableEnded) res.end("Bad Gateway");
+      try { client.close(); } catch {}
+      resolve();
+    });
 
-    const forwardReq = https.request({
-      hostname: targetIP,
-      port: 443,
-      path: req.url,
-      method: req.method,
-      headers: { ...req.headers, host: targetHost },
-      servername: targetHost,
-      rejectUnauthorized: false
-    }, (forwardRes) => {
-      // When transformResponse is provided, buffer the full response so we can
-      // modify it before sending to the client.
-      const shouldBuffer = transformResponse != null;
-      if (!shouldBuffer) res.writeHead(forwardRes.statusCode, forwardRes.headers);
-
-      if (!onResponse && !dumper && !shouldBuffer) {
-        forwardRes.pipe(res);
-        return;
+    const stream = client.request(h2Headers, { endStream: bodyBuffer.length === 0 });
+    if (bodyBuffer.length > 0) stream.end(bodyBuffer);
+
+    stream.once("response", (responseHeaders) => {
+      const status = responseHeaders[":status"];
+      // Filter pseudo-headers + connection-specific
+      const outHeaders = {};
+      for (const [k, v] of Object.entries(responseHeaders)) {
+        if (k.startsWith(":")) continue;
+        if (k === "connection" || k === "keep-alive" || k === "transfer-encoding") continue;
+        outHeaders[k] = v;
       }
+      res.writeHead(status, outHeaders);
+      if (dumper) dumper.writeHeader(status, outHeaders);
 
       const chunks = [];
-      forwardRes.on("data", chunk => {
+      stream.on("data", chunk => {
         if (dumper) dumper.writeChunk(chunk);
-        if (onResponse || shouldBuffer) chunks.push(chunk);
-        if (!shouldBuffer) res.write(chunk);
+        if (onResponse) chunks.push(chunk);
+        res.write(chunk);
       });
-      forwardRes.on("end", () => {
-        const rawBuffer = Buffer.concat(chunks);
-
-        if (shouldBuffer) {
-          try {
-            const modified = transformResponse(rawBuffer, forwardRes.headers);
-            // Update Content-Length if present to match modified body
-            const headers = { ...forwardRes.headers };
-            if (headers["content-length"] != null) {
-              headers["content-length"] = String(Buffer.byteLength(modified));
-            }
-            res.writeHead(forwardRes.statusCode, headers);
-            res.end(modified);
-          } catch (e) {
-            err(`transformResponse error: ${e.message}`);
-            if (!res.headersSent) res.writeHead(502);
-            res.end("Bad Gateway");
-          }
-        } else {
-          res.end();
-        }
-
+      stream.on("end", () => {
         if (dumper) dumper.end();
-        if (onResponse) try { onResponse(rawBuffer, forwardRes.headers); } catch { /* ignore */ }
+        if (!res.writableEnded) res.end();
+        if (onResponse) try { onResponse(Buffer.concat(chunks), outHeaders); } catch {}
+        try { client.close(); } catch {}
+        resolve();
       });
     });
-
-    forwardReq.on("error", (e) => {
-      if (attempt === 0 && (e.code === "EADDRNOTAVAIL" || /secure TLS connection/i.test(e.message || ""))) {
-        delete cachedTargetIPs[targetHost];
-        log(`⏩ passthrough retry | ${targetHost} | ${targetIP} failed: ${e.code || e.message}`);
-        startForward(1, [targetIP]);
-        return;
-      }
-      err(`Passthrough error: ${e.message}`);
-      if (dumper) { dumper.writeChunk(`\n[ERROR] ${e.message}\n`); dumper.end(); }
+    stream.once("error", (e) => {
+      err(`[mitm] http2 stream error: ${e.message}`);
+      if (dumper) { dumper.writeChunk(`\n[ERROR h2-stream] ${e.message}\n`); dumper.end(); }
       if (!res.headersSent) res.writeHead(502);
-      res.end("Bad Gateway");
+      if (!res.writableEnded) res.end();
+      try { client.close(); } catch {}
+      resolve();
     });
-    forwardReq.setTimeout(PASSTHROUGH_CONNECT_TIMEOUT_MS, () => {
-      forwardReq.destroy(new Error(`Passthrough timed out connecting to ${targetHost}`));
+  });
+}
+
+// Fallback: raw https.request HTTP/1.1 with custom DNS (bypasses /etc/hosts MITM loop)
+async function passthroughHttps(req, res, bodyBuffer, headers, targetHost, onResponse, dumper) {
+  const targetIP = await resolveTargetIP(targetHost);
+  const forwardReq = https.request({
+    hostname: targetIP,
+    port: 443,
+    path: req.url,
+    method: req.method,
+    headers,
+    servername: targetHost,
+    rejectUnauthorized: false
+  }, (forwardRes) => {
+    res.writeHead(forwardRes.statusCode, forwardRes.headers);
+    if (dumper) dumper.writeHeader(forwardRes.statusCode, forwardRes.headers);
+
+    if (!onResponse && !dumper) {
+      forwardRes.pipe(res);
+      return;
+    }
+
+    const chunks = [];
+    forwardRes.on("data", chunk => {
+      if (dumper) dumper.writeChunk(chunk);
+      if (onResponse) chunks.push(chunk);
+      res.write(chunk);
     });
+    forwardRes.on("end", () => {
+      if (dumper) dumper.end();
+      res.end();
+      if (onResponse) try { onResponse(Buffer.concat(chunks), forwardRes.headers); } catch { /* ignore */ }
+    });
+  });
 
-    if (bodyBuffer.length > 0) forwardReq.write(bodyBuffer);
-    forwardReq.end();
-  };
+  forwardReq.on("error", (e) => {
+    err(`Passthrough error: ${e.message}`);
+    if (dumper) { dumper.writeChunk(`\n[ERROR] ${e.message}\n`); dumper.end(); }
+    if (!res.headersSent) res.writeHead(502);
+    res.end("Bad Gateway");
+  });
 
-  await startForward();
+  if (bodyBuffer.length > 0) forwardReq.write(bodyBuffer);
+  forwardReq.end();
 }
 
 // ── Request handler ───────────────────────────────────────────
@@ -424,9 +332,9 @@ const server = https.createServer(sslOptions, async (req, res) => {
     }
 
     const bodyBuffer = await collectBodyRaw(req);
-    if (ENABLE_FILE_LOG && shouldDumpRequest(req)) dumpRequest(req, bodyBuffer, "raw");
+    if (ENABLE_FILE_LOG) dumpRequest(req, bodyBuffer, "raw");
 
-    // Anti-loop: skip requests from OpenrouterX
+    // Anti-loop: skip requests from 9Router
     if (req.headers[INTERNAL_REQUEST_HEADER.name] === INTERNAL_REQUEST_HEADER.value) {
       return passthrough(req, res, bodyBuffer);
     }
@@ -434,12 +342,6 @@ const server = https.createServer(sslOptions, async (req, res) => {
     const tool = getToolForHost(req.headers.host);
     if (!tool) return passthrough(req, res, bodyBuffer);
 
-    if (tool === "antigravity" && handleLocalAntigravityBootstrap(req, res)) return;
-    if (tool === "antigravity" && req.url.includes(":loadCodeAssist")) {
-      log("🧩 loadCodeAssist MITM | passthrough inspect");
-      return passthrough(req, res, bodyBuffer, inspectAntigravityLoadCodeAssist);
-    }
-
     const patterns = URL_PATTERNS[tool] || [];
     const isChat = patterns.some(p => req.url.includes(p));
     if (!isChat) return passthrough(req, res, bodyBuffer);
@@ -451,15 +353,20 @@ const server = https.createServer(sslOptions, async (req, res) => {
     }
 
     const model = extractModel(req.url, bodyBuffer);
+
+    // Intentional passthrough: some models must never be re-routed (e.g. Antigravity
+    // tab-autocomplete) so latency-critical inline completion stays native. Silent — this
+    // is by design, not a leak, and fires per keystroke. See MODEL_NO_MAP in config.js.
+    if (model && (MODEL_NO_MAP[tool] || []).some((re) => re.test(model))) {
+      return passthrough(req, res, bodyBuffer);
+    }
+
     const mappedModel = getMappedModel(tool, model);
-    const aliasMappings = getMitmAlias(tool) || {};
-    if (!mappedModel && tool !== "openrouter" && !req.url.includes("/models")) {
-      log(`⏩ passthrough | no mapping | ${tool} | ${model || "unknown"}`);
+    if (!mappedModel) {
       return passthrough(req, res, bodyBuffer);
     }
 
-    log(`⚡ intercept | ${tool} | ${model || req.url} → ${mappedModel || "dynamic"}`);
-    return handlers[tool].intercept(req, res, bodyBuffer, mappedModel, passthrough, aliasMappings);
+    return handlers[tool].intercept(req, res, bodyBuffer, mappedModel, passthrough);
   } catch (e) {
     err(`Unhandled error: ${e.message}`);
     if (!res.headersSent) res.writeHead(500, { "Content-Type": "application/json" });
@@ -478,7 +385,7 @@ function killPort(port) {
       if (!out) return;
       pidList = out.split(/\r?\n/).map(s => s.trim()).filter(p => p && Number(p) !== process.pid && Number(p) > 4);
     } else {
-      const out = execSync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`, { encoding: "utf-8", windowsHide: true }).trim();
+      const out = execSync(`${LSOF_BIN} -nP -iTCP:${port} -sTCP:LISTEN -t`, { encoding: "utf-8", windowsHide: true }).trim();
       if (!out) return;
       pidList = out.split("\n").filter(p => p && Number(p) !== process.pid);
     }

package/app/src/shared/constants/mitmToolHosts.js

@@ -3,15 +3,10 @@
  * Kept in sync with MITM routing; shared by Node (dnsConfig) and dashboard UI.
  */
 const TOOL_HOSTS = {
-  antigravity: [
-    "daily-cloudcode-pa.googleapis.com",
-    "cloudcode-pa.googleapis.com",
-    "daily-cloudcode-pa.sandbox.googleapis.com",
-  ],
+  antigravity: ["daily-cloudcode-pa.googleapis.com", "cloudcode-pa.googleapis.com"],
   copilot: ["api.individual.githubcopilot.com"],
   kiro: ["q.us-east-1.amazonaws.com", "codewhisperer.us-east-1.amazonaws.com"],
   cursor: ["api2.cursor.sh"],
-  openrouter: ["openrouter.ai", "api.openrouter.ai"],
 };
 
 module.exports = { TOOL_HOSTS };