9router 0.3.46 → 0.3.48

package/app/src/mitm/server copy.js

@@ -0,0 +1,737 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const dns = require("dns");
+const { promisify } = require("util");
+
+const INTERNAL_REQUEST_HEADER = { name: "x-request-source", value: "local" };
+
+// All intercepted domains across all tools
+const TARGET_HOSTS = [
+  "daily-cloudcode-pa.googleapis.com",
+  "cloudcode-pa.googleapis.com",
+  "api.individual.githubcopilot.com",
+];
+
+const LOCAL_PORT = 443;
+const ROUTER_URL = "http://localhost:20128/v1/chat/completions";
+const API_KEY = process.env.ROUTER_API_KEY;
+const { DATA_DIR, MITM_DIR } = require("./paths");
+const DB_FILE = path.join(DATA_DIR, "db.json");
+
+const ENABLE_FILE_LOG = false;
+const CURSOR_LOG_DIR = path.join(__dirname, "../../logs/cursor");
+if (!fs.existsSync(CURSOR_LOG_DIR)) fs.mkdirSync(CURSOR_LOG_DIR, { recursive: true });
+const CURSOR_JSONL = path.join(CURSOR_LOG_DIR, "cursor_messages.jsonl");
+
+const CURSOR_ENDPOINTS = [
+  "/agent.v1.AgentService/RunPoll",
+  "/aiserver.v1.BidiService/BidiAppend",
+];
+
+/**
+ * Decode Connect-RPC frame: [1 byte flags][4 bytes length][protobuf body]
+ * Then walk raw protobuf fields and extract readable strings/numbers.
+ */
+function decodeConnectFrame(buf) {
+  if (!buf || buf.length < 5) return null;
+  const msgLen = buf.readUInt32BE(1);
+  if (buf.length < 5 + msgLen) return null;
+  return decodeProtoRaw(buf.slice(5, 5 + msgLen));
+}
+
+function decodeProtoRaw(buf, depth = 0) {
+  if (depth > 6) return {};
+  const result = {};
+  let offset = 0;
+  try {
+    while (offset < buf.length) {
+      const tag = readVarint(buf, offset);
+      if (!tag) break;
+      offset += tag.bytes;
+      const fieldNum = tag.value >> 3;
+      const wireType = tag.value & 0x7;
+
+      if (wireType === 0) {
+        // varint
+        const v = readVarint(buf, offset);
+        if (!v) break;
+        offset += v.bytes;
+        result[`f${fieldNum}`] = v.value;
+      } else if (wireType === 2) {
+        // length-delimited: string, bytes, or nested message
+        const lenV = readVarint(buf, offset);
+        if (!lenV) break;
+        offset += lenV.bytes;
+        const data = buf.slice(offset, offset + lenV.value);
+        offset += lenV.value;
+        // Try as UTF-8 string first
+        const str = data.toString("utf8");
+        const isPrintable = /^[\x20-\x7E\n\r\t]*$/.test(str) && str.length > 0;
+        if (isPrintable) {
+          result[`f${fieldNum}`] = str;
+        } else if (data.length > 0 && data.length < 4096) {
+          // Try nested decode
+          const nested = decodeProtoRaw(data, depth + 1);
+          result[`f${fieldNum}`] = Object.keys(nested).length ? nested : data.toString("hex").substring(0, 64);
+        }
+      } else if (wireType === 5) {
+        offset += 4;
+      } else if (wireType === 1) {
+        offset += 8;
+      } else {
+        break;
+      }
+    }
+  } catch { /* best effort */ }
+  return result;
+}
+
+function readVarint(buf, offset) {
+  let value = 0, shift = 0, bytes = 0;
+  while (offset + bytes < buf.length) {
+    const b = buf[offset + bytes++];
+    value |= (b & 0x7f) << shift;
+    shift += 7;
+    if (!(b & 0x80)) return { value, bytes };
+    if (shift >= 28) break;
+  }
+  return null;
+}
+
+const zlib = require("zlib");
+
+/**
+ * Deep decode protobuf buffer — returns structured object.
+ * Tries to interpret each length-delimited field as:
+ *   1. UTF-8 string (if fully printable)
+ *   2. Nested proto message (recursive)
+ *   3. Hex string fallback
+ */
+function deepDecodeProto(buf, depth = 0) {
+  if (depth > 10 || buf.length === 0) return null;
+  const result = {};
+  let off = 0;
+  try {
+    while (off < buf.length) {
+      // Read varint tag
+      let tag = 0, shift = 0;
+      while (off < buf.length) {
+        const b = buf[off++];
+        tag |= (b & 0x7f) << shift;
+        shift += 7;
+        if (!(b & 0x80)) break;
+        if (shift > 28) break;
+      }
+      if (tag === 0) break;
+      const field = tag >> 3;
+      const wire = tag & 7;
+      const key = `f${field}`;
+
+      if (wire === 0) {
+        // varint
+        let v = 0, s = 0;
+        while (off < buf.length) {
+          const b = buf[off++];
+          v |= (b & 0x7f) << s;
+          s += 7;
+          if (!(b & 0x80)) break;
+        }
+        result[key] = v;
+      } else if (wire === 2) {
+        // length-delimited
+        let len = 0, s = 0;
+        while (off < buf.length) {
+          const b = buf[off++];
+          len |= (b & 0x7f) << s;
+          s += 7;
+          if (!(b & 0x80)) break;
+        }
+        if (off + len > buf.length || len < 0) break;
+        const data = buf.slice(off, off + len);
+        off += len;
+
+        if (len === 0) {
+          result[key] = "";
+          continue;
+        }
+
+        // Try UTF-8 string
+        const str = data.toString("utf8");
+        const isPrintable = str.length > 0 && !/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(str);
+        if (isPrintable) {
+          // Accumulate repeated fields as array
+          if (key in result) {
+            result[key] = [].concat(result[key], str);
+          } else {
+            result[key] = str;
+          }
+          continue;
+        }
+
+        // Try nested proto
+        if (len >= 2 && len <= 500000) {
+          const nested = deepDecodeProto(data, depth + 1);
+          if (nested && Object.keys(nested).length > 0) {
+            if (key in result) {
+              result[key] = [].concat(result[key], [nested]);
+            } else {
+              result[key] = nested;
+            }
+            continue;
+          }
+        }
+
+        // Fallback: hex (truncate at 64 bytes)
+        result[key] = data.slice(0, 64).toString("hex");
+      } else if (wire === 5) {
+        off += 4;
+      } else if (wire === 1) {
+        off += 8;
+      } else {
+        break;
+      }
+    }
+  } catch { /* best effort */ }
+  return result;
+}
+
+// ── Proto helpers ──────────────────────────────────────────────
+function protoReadVarint(buf, off) {
+  let v = 0, shift = 0;
+  while (off < buf.length) {
+    const b = buf[off++];
+    v |= (b & 0x7f) << shift;
+    shift += 7;
+    if (!(b & 0x80)) return { v, off };
+    if (shift > 49) break;
+  }
+  return null;
+}
+
+function protoWalkFields(buf) {
+  const fields = [];
+  let off = 0;
+  while (off < buf.length) {
+    const t = protoReadVarint(buf, off);
+    if (!t || t.v === 0) break;
+    off = t.off;
+    const field = t.v >> 3, wire = t.v & 7;
+    if (wire === 0) {
+      const r = protoReadVarint(buf, off);
+      if (!r) break;
+      off = r.off;
+      fields.push({ field, wire, value: r.v });
+    } else if (wire === 2) {
+      const r = protoReadVarint(buf, off);
+      if (!r) break;
+      off = r.off;
+      if (off + r.v > buf.length) break;
+      fields.push({ field, wire, data: buf.slice(off, off + r.v) });
+      off += r.v;
+    } else if (wire === 5) { off += 4; }
+    else if (wire === 1) { off += 8; }
+    else break;
+  }
+  return fields;
+}
+
+function protoStr(buf) {
+  if (!buf || buf.length === 0) return null;
+  const s = buf.toString("utf8");
+  return /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(s) ? null : s;
+}
+
+// ── Schema-aware decoders ──────────────────────────────────────
+
+// BidiAppendRequest: f1=data(hex-encoded AgentClientMessage), f2=requestId{f1=uuid}, f3=seqno
+function decodeBidiAppend(buf) {
+  const fields = protoWalkFields(buf);
+  const result = {};
+  for (const f of fields) {
+    if (f.field === 1 && f.data) {
+      // f1.data is ASCII hex string → decode to actual proto bytes
+      try {
+        const hexStr = f.data.toString("utf8");
+        const protoBytes = Buffer.from(hexStr, "hex");
+        result.agentMsg = decodeAgentClientMsg(protoBytes);
+      } catch { result.agentMsg = { type: "hex_decode_error" }; }
+    } else if (f.field === 2 && f.data) {
+      const inner = protoWalkFields(f.data);
+      const id = inner.find(x => x.field === 1 && x.data);
+      result.requestId = id ? protoStr(id.data) : null;
+    } else if (f.field === 3) result.seqno = f.value;
+  }
+  return result;
+}
+
+// AgentClientMessage oneof: f1=AgentRunRequest, f4=ConversationAction, f7=ClientHeartbeat
+function decodeAgentClientMsg(buf) {
+  const fields = protoWalkFields(buf);
+  for (const f of fields) {
+    if (!f.data) continue;
+    if (f.field === 1) return { type: "AgentRunRequest", ...decodeAgentRunRequest(f.data) };
+    if (f.field === 4) return { type: "ConversationAction", ...decodeConversationAction(f.data) };
+    if (f.field === 7) return { type: "ClientHeartbeat" };
+    if (f.field === 2) return { type: "ExecClientMessage" };
+  }
+  return { type: "unknown" };
+}
+
+// AgentRunRequest: f1=conversation_state, f2=action, f3=model_details, f5=conversation_id
+function decodeAgentRunRequest(buf) {
+  const fields = protoWalkFields(buf);
+  const result = {};
+
+  for (const f of fields) {
+    if (f.field === 3 && f.data) result.model = decodeModelDetails(f.data);
+    if (f.field === 5 && f.data) result.conversationId = protoStr(f.data);
+    if (f.field === 2 && f.data) result.action = decodeConversationAction(f.data);
+    if (f.field === 1 && f.data) result.state = decodeConversationState(f.data);
+  }
+  return result;
+}
+
+// ModelDetails — scan all string fields
+function decodeModelDetails(buf) {
+  const fields = protoWalkFields(buf);
+  const result = {};
+  for (const f of fields) {
+    if (f.data) {
+      const s = protoStr(f.data);
+      if (s && s.length > 0) result[`f${f.field}`] = s;
+    } else if (f.value !== undefined) {
+      result[`f${f.field}`] = f.value;
+    }
+  }
+  return result;
+}
+
+// ConversationAction: f1 → f1 → f1=text, f2=uuid, f8=lexical_json
+//                    f1 → f2 → repeated f2=turns, f7=selected_context, f23=system_prompt
+function decodeConversationAction(buf) {
+  const result = {};
+  const topFields = protoWalkFields(buf);
+
+  // action.f1 wrapper
+  const f1 = topFields.find(f => f.field === 1 && f.data);
+  if (!f1) return result;
+  const f1Fields = protoWalkFields(f1.data);
+
+  // ── User message: action.f1.f1 ──────────────────────────────
+  const f1f1 = f1Fields.find(f => f.field === 1 && f.data);
+  if (f1f1) {
+    for (const f of protoWalkFields(f1f1.data)) {
+      if (!f.data) continue;
+      const s = protoStr(f.data);
+      if (f.field === 1 && s) result.text = s;
+      if (f.field === 2 && s) result.messageId = s;
+      if (f.field === 8 && s) {
+        try {
+          const lex = JSON.parse(s);
+          const texts = [];
+          function extractLexText(node) {
+            if (node?.text) texts.push(node.text);
+            (node?.children || []).forEach(extractLexText);
+          }
+          extractLexText(lex?.root);
+          result.textFull = texts.join("");
+        } catch { result.lexical = s.substring(0, 300); }
+      }
+    }
+  }
+
+  // ── Conversation history: action.f1.f2 ──────────────────────
+  const f1f2 = f1Fields.find(f => f.field === 2 && f.data);
+  if (f1f2) {
+    const histFields = protoWalkFields(f1f2.data);
+
+    // f2 repeated = context files (rules, open files...)
+    result.contextFiles = histFields
+      .filter(f => f.field === 2 && f.data)
+      .map(t => {
+        const tf = protoWalkFields(t.data);
+        const name = tf.find(f => f.field === 1 && f.data);
+        const content = tf.find(f => f.field === 2 && f.data);
+        return {
+          path: name ? protoStr(name.data) : null,
+          content: content ? protoStr(content.data)?.substring(0, 500) : null,
+        };
+      })
+      .filter(x => x.path);
+
+    // f7 repeated = MCP tools
+    result.tools = histFields
+      .filter(f => f.field === 7 && f.data)
+      .map(t => {
+        const tf = protoWalkFields(t.data);
+        const name = tf.find(f => f.field === 1 && f.data);
+        const desc = tf.find(f => f.field === 2 && f.data);
+        return {
+          name: name ? protoStr(name.data) : null,
+          description: desc ? protoStr(desc.data) : null,
+        };
+      })
+      .filter(x => x.name);
+
+  }
+
+  return result;
+}
+
+/**
+ * Recursively decode any proto buffer into a plain JS object for debugging.
+ * Each field: try UTF-8 string → nested proto → hex fallback.
+ * Repeated fields become arrays.
+ */
+function protoTreeToObj(buf, depth = 0) {
+  if (depth > 12 || !buf || buf.length === 0) return null;
+  const result = {};
+  const fields = protoWalkFields(buf);
+  for (const f of fields) {
+    const key = `f${f.field}`;
+    let val;
+    if (f.data !== undefined) {
+      const s = protoStr(f.data);
+      if (s !== null) {
+        // Detect hex-encoded proto (BidiAppend.data field)
+        if (/^[0-9a-f]{20,}$/i.test(s)) {
+          try {
+            const dec = protoTreeToObj(Buffer.from(s, "hex"), depth + 1);
+            val = (dec && Object.keys(dec).length > 0) ? dec : s;
+          } catch { val = s; }
+        } else {
+          try { val = JSON.parse(s); } catch { val = s; }
+        }
+      } else if (f.data.length > 0) {
+        const nested = protoTreeToObj(f.data, depth + 1);
+        val = (nested && Object.keys(nested).length > 0)
+          ? nested
+          : f.data.toString("hex");
+      } else {
+        val = "";
+      }
+    } else {
+      val = f.value;
+    }
+    // Accumulate repeated fields as array
+    if (key in result) {
+      result[key] = [].concat(result[key], [val]);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+
+  return result;
+}
+
+// ConversationStateStructure: f1=root_prompt_messages_json(bytes[]), f8=turns(bytes[])
+function decodeConversationState(buf) {
+  const fields = protoWalkFields(buf);
+  const messages = [], turns = [];
+  for (const f of fields) {
+    if (!f.data) continue;
+    if (f.field === 1) {
+      // root_prompt_messages_json — each is a bytes field containing JSON string
+      const s = protoStr(f.data);
+      if (s) { try { messages.push(JSON.parse(s)); } catch { messages.push(s.substring(0, 500)); } }
+    } else if (f.field === 8) {
+      // turns — bytes, try get readable strings
+      const inner = protoWalkFields(f.data);
+      const strs = inner.filter(x => x.data && protoStr(x.data)).map(x => protoStr(x.data)).filter(s => s.length > 5);
+      if (strs.length) turns.push(strs.slice(0, 5));
+    }
+  }
+  return { messages: messages.slice(0, 10), turns: turns.slice(0, 5) };
+}
+
+// ── Save per-chat JSON file ────────────────────────────────────
+function saveCursorLogFull(url, headers, buf) {
+  try {
+    if (!url.includes("BidiAppend") || buf.length < 2 || buf[0] !== 0x1f || buf[1] !== 0x8b) return;
+
+    const decompressed = zlib.gunzipSync(buf);
+
+
+    const decoded = decodeBidiAppend(decompressed);
+
+    const action = decoded?.agentMsg?.action || {};
+    const userMessage = action.textFull || action.text || null;
+
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const base = path.join(CURSOR_LOG_DIR, ts);
+
+    // _chat.json — structured decoded
+    fs.writeFileSync(`${base}_chat.json`, JSON.stringify({
+      ts: new Date().toISOString(),
+      version: headers["x-cursor-client-version"],
+      sizeGzip: buf.length,
+      sizeRaw: decompressed.length,
+      userMessage,
+      decoded,
+    }, null, 2));
+
+    // _decoded.json — full proto tree, no filtering
+    const tree = protoTreeToObj(decompressed);
+    fs.writeFileSync(`${base}_decoded.json`, JSON.stringify(tree, null, 2));
+
+    console.log(`[CURSOR] ${ts}_chat.json | type=${decoded?.agentMsg?.type} | msg=${userMessage || "(none)"}`);
+  } catch (e) {
+    console.error(`[CURSOR] decode error: ${e.message}`);
+  }
+}
+
+if (!API_KEY) {
+  console.error("❌ ROUTER_API_KEY required");
+  process.exit(1);
+}
+
+const { getCertForDomain } = require("./cert/generate");
+
+// Certificate cache for performance
+const certCache = new Map();
+
+// SNI callback for dynamic certificate generation
+function sniCallback(servername, cb) {
+  try {
+    // Check cache first
+    if (certCache.has(servername)) {
+      const cached = certCache.get(servername);
+      return cb(null, cached);
+    }
+
+    // Generate new cert for this domain
+    const certData = getCertForDomain(servername);
+    if (!certData) {
+      return cb(new Error(`Failed to generate cert for ${servername}`));
+    }
+
+    // Create secure context
+    const ctx = require("tls").createSecureContext({
+      key: certData.key,
+      cert: certData.cert
+    });
+
+    // Cache it
+    certCache.set(servername, ctx);
+    console.log(`✅ Generated cert for: ${servername}`);
+
+    cb(null, ctx);
+  } catch (error) {
+    console.error(`❌ SNI error for ${servername}:`, error.message);
+    cb(error);
+  }
+}
+
+// Load Root CA for default context
+const certDir = MITM_DIR;
+const rootCAKeyPath = path.join(certDir, "rootCA.key");
+const rootCACertPath = path.join(certDir, "rootCA.crt");
+
+let sslOptions;
+try {
+  sslOptions = {
+    key: fs.readFileSync(rootCAKeyPath),
+    cert: fs.readFileSync(rootCACertPath),
+    SNICallback: sniCallback
+  };
+} catch (e) {
+  console.error(`❌ Root CA not found in ${certDir}: ${e.message}`);
+  process.exit(1);
+}
+
+// Antigravity: Gemini generateContent endpoints
+const ANTIGRAVITY_URL_PATTERNS = [":generateContent", ":streamGenerateContent"];
+// Copilot: OpenAI-compatible + Anthropic endpoints
+const COPILOT_URL_PATTERNS = ["/chat/completions", "/v1/messages", "/responses"];
+
+const LOG_DIR = path.join(__dirname, "../../logs/mitm");
+if (ENABLE_FILE_LOG && !fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+
+function saveRequestLog(url, bodyBuffer) {
+  if (!ENABLE_FILE_LOG) return;
+  try {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const urlSlug = url.replace(/[^a-zA-Z0-9]/g, "_").substring(0, 60);
+    const filePath = path.join(LOG_DIR, `${ts}_${urlSlug}.json`);
+    const body = JSON.parse(bodyBuffer.toString());
+    fs.writeFileSync(filePath, JSON.stringify(body, null, 2));
+  } catch { /* ignore */ }
+}
+
+const cachedTargetIPs = {};
+async function resolveTargetIP(hostname) {
+  if (cachedTargetIPs[hostname]) return cachedTargetIPs[hostname];
+  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] = addresses[0];
+  return cachedTargetIPs[hostname];
+}
+
+function collectBodyRaw(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", chunk => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+// Extract model from URL path (Gemini) or body (OpenAI/Anthropic)
+function extractModel(url, body) {
+  const urlMatch = url.match(/\/models\/([^/:]+)/);
+  if (urlMatch) return urlMatch[1];
+  try { return JSON.parse(body.toString()).model || null; } catch { return null; }
+}
+
+function getMappedModel(tool, model) {
+  if (!model) return null;
+  try {
+    if (!fs.existsSync(DB_FILE)) return null;
+    const db = JSON.parse(fs.readFileSync(DB_FILE, "utf-8"));
+    return db.mitmAlias?.[tool]?.[model] || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Determine which tool this request belongs to based on hostname
+ */
+function getToolForHost(host) {
+  const h = (host || "").split(":")[0];
+  if (h === "api.individual.githubcopilot.com") return "copilot";
+  if (h === "daily-cloudcode-pa.googleapis.com" || h === "cloudcode-pa.googleapis.com") return "antigravity";
+  return null;
+}
+
+async function passthrough(req, res, bodyBuffer) {
+  const targetHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
+  const targetIP = await resolveTargetIP(targetHost);
+
+  const forwardReq = https.request({
+    hostname: targetIP,
+    port: 443,
+    path: req.url,
+    method: req.method,
+    headers: { ...req.headers, host: targetHost },
+    servername: targetHost,
+    rejectUnauthorized: false
+  }, (forwardRes) => {
+    res.writeHead(forwardRes.statusCode, forwardRes.headers);
+    forwardRes.pipe(res);
+  });
+
+  forwardReq.on("error", (err) => {
+    console.error(`❌ Passthrough error: ${err.message}`);
+    if (!res.headersSent) res.writeHead(502);
+    res.end("Bad Gateway");
+  });
+
+  if (bodyBuffer.length > 0) forwardReq.write(bodyBuffer);
+  forwardReq.end();
+}
+
+async function intercept(req, res, bodyBuffer, mappedModel) {
+  try {
+    const body = JSON.parse(bodyBuffer.toString());
+    body.model = mappedModel;
+
+    const response = await fetch(ROUTER_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${API_KEY}`
+      },
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      throw new Error(`9Router ${response.status}: ${errText}`);
+    }
+
+    const ct = response.headers.get("content-type") || "application/json";
+    const resHeaders = { "Content-Type": ct, "Cache-Control": "no-cache", "Connection": "keep-alive" };
+    if (ct.includes("text/event-stream")) resHeaders["X-Accel-Buffering"] = "no";
+    res.writeHead(200, resHeaders);
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) { res.end(); break; }
+      res.write(decoder.decode(value, { stream: true }));
+    }
+  } catch (error) {
+    console.error(`❌ ${error.message}`);
+    if (!res.headersSent) res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: { message: error.message, type: "mitm_error" } }));
+  }
+}
+
+const server = https.createServer(sslOptions, async (req, res) => {
+  if (req.url === "/_mitm_health") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, pid: process.pid }));
+    return;
+  }
+
+  console.log(`[MITM] ${req.method} https://${req.headers.host}${req.url}`);
+
+  const bodyBuffer = await collectBodyRaw(req);
+  if (bodyBuffer.length > 0) saveRequestLog(req.url, bodyBuffer);
+
+  // Decode and log Cursor protobuf endpoints
+  if (CURSOR_ENDPOINTS.some(e => req.url.includes(e))) {
+    saveCursorLogFull(req.url, req.headers, bodyBuffer);
+  }
+
+  // Anti-loop: requests originating from 9Router bypass interception
+  if (req.headers[INTERNAL_REQUEST_HEADER.name] === INTERNAL_REQUEST_HEADER.value) {
+    return passthrough(req, res, bodyBuffer);
+  }
+
+  const tool = getToolForHost(req.headers.host);
+  if (!tool) return passthrough(req, res, bodyBuffer);
+
+  // Check if this URL should be intercepted based on tool
+  const isChat = tool === "antigravity"
+    ? ANTIGRAVITY_URL_PATTERNS.some(p => req.url.includes(p))
+    : COPILOT_URL_PATTERNS.some(p => req.url.includes(p));
+
+  if (!isChat) return passthrough(req, res, bodyBuffer);
+
+  const model = extractModel(req.url, bodyBuffer);
+  console.log("Extracted model:",  model)
+  const mappedModel = getMappedModel(tool, model);
+
+  if (!mappedModel) return passthrough(req, res, bodyBuffer);
+
+  return intercept(req, res, bodyBuffer, mappedModel);
+});
+
+server.listen(LOCAL_PORT, () => {
+  console.log(`🚀 MITM ready on :${LOCAL_PORT}`);
+});
+
+server.on("error", (error) => {
+  if (error.code === "EADDRINUSE") {
+    console.error(`❌ Port ${LOCAL_PORT} already in use`);
+  } else if (error.code === "EACCES") {
+    console.error(`❌ Permission denied for port ${LOCAL_PORT}`);
+  } else {
+    console.error(`❌ ${error.message}`);
+  }
+  process.exit(1);
+});
+
+const shutdown = () => { server.close(() => process.exit(0)); };
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+if (process.platform === "win32") {
+  process.on("SIGBREAK", shutdown);
+}