@yina-npm/openrouterx 0.4.56 → 0.4.71

package/app/src/mitm/antigravityIdeVersion.js

@@ -0,0 +1,50 @@
+"use strict";
+
+// Rewrite Antigravity IDE markers so upstream AG 2.x backend accepts the request.
+// User-Agent header (antigravity/<old>) and body.metadata.ideVersion are forced
+// to a known-good IDE version. Hardcoded MVP — toggle/version configurable later.
+
+const ANTIGRAVITY_IDE_VERSION = "1.23.2";
+const ANTIGRAVITY_IDE_VERSION_OVERRIDE_ENABLED = true;
+
+function shouldRewriteMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return false;
+  if (String(metadata.ideName || "").toLowerCase() === "antigravity") return true;
+  if (String(metadata.ideType || "").toUpperCase() === "ANTIGRAVITY") return true;
+  return Object.prototype.hasOwnProperty.call(metadata, "ideVersion");
+}
+
+function rewriteAntigravityUserAgent(userAgent, version) {
+  if (typeof userAgent !== "string" || !userAgent.includes("antigravity/")) return userAgent;
+  return userAgent.replace(/antigravity\/[^\s]+/, `antigravity/${version}`);
+}
+
+function applyAntigravityIdeVersionOverride(bodyBuffer, headers) {
+  if (!ANTIGRAVITY_IDE_VERSION_OVERRIDE_ENABLED) {
+    return { bodyBuffer, headers, applied: false, version: ANTIGRAVITY_IDE_VERSION };
+  }
+
+  const nextHeaders = { ...headers };
+  const nextUserAgent = rewriteAntigravityUserAgent(nextHeaders["user-agent"], ANTIGRAVITY_IDE_VERSION);
+  const userAgentChanged = nextUserAgent !== nextHeaders["user-agent"];
+  if (userAgentChanged) nextHeaders["user-agent"] = nextUserAgent;
+
+  try {
+    const parsed = JSON.parse(bodyBuffer.toString());
+    if (!shouldRewriteMetadata(parsed?.metadata)) {
+      return { bodyBuffer, headers: nextHeaders, applied: userAgentChanged, version: ANTIGRAVITY_IDE_VERSION };
+    }
+
+    parsed.metadata.ideVersion = ANTIGRAVITY_IDE_VERSION;
+    const nextBodyBuffer = Buffer.from(JSON.stringify(parsed));
+    return { bodyBuffer: nextBodyBuffer, headers: nextHeaders, applied: true, version: ANTIGRAVITY_IDE_VERSION };
+  } catch {
+    return { bodyBuffer, headers: nextHeaders, applied: userAgentChanged, version: ANTIGRAVITY_IDE_VERSION };
+  }
+}
+
+module.exports = {
+  ANTIGRAVITY_IDE_VERSION,
+  applyAntigravityIdeVersionOverride,
+  rewriteAntigravityUserAgent,
+};

package/app/src/mitm/cert/install.js

@@ -4,14 +4,30 @@ const { exec } = require("child_process");
 const { execWithPassword, isSudoAvailable } = require("../dns/dnsConfig.js");
 const { runElevatedPowerShell, quotePs } = require("../winElevated.js");
 const { log, err } = require("../logger");
-const { ROOT_CA_CN } = require("./rootCA.js");
 
 const IS_WIN = process.platform === "win32";
 const IS_MAC = process.platform === "darwin";
-const LINUX_CERT_DIR = "/usr/local/share/ca-certificates";
-const LEGACY_ROOT_CA_CN = "9Router MITM Root CA";
-const LINUX_CERT_FILE = `${LINUX_CERT_DIR}/openrouterx-root-ca.crt`;
-const LEGACY_LINUX_CERT_FILE = `${LINUX_CERT_DIR}/9router-root-ca.crt`;
+const LINUX_CERT_PATHS = [
+  // Debian / Ubuntu
+  { dir: "/usr/local/share/ca-certificates", cmd: "update-ca-certificates" },
+  // Arch Linux / CachyOS / Manjaro
+  { dir: "/etc/ca-certificates/trust-source/anchors", cmd: "update-ca-trust" },
+  // Fedora / RHEL / CentOS
+  { dir: "/etc/pki/ca-trust/source/anchors", cmd: "update-ca-trust" },
+  // openSUSE
+  { dir: "/etc/pki/trust/anchors", cmd: "update-ca-certificates" }
+];
+
+function getLinuxCertConfig() {
+  for (const config of LINUX_CERT_PATHS) {
+    if (fs.existsSync(config.dir)) {
+      return config;
+    }
+  }
+  // Fallback to Debian default if none exist
+  return LINUX_CERT_PATHS[0];
+}
+const ROOT_CA_CN = "9Router MITM Root CA";
 
 // Get SHA1 fingerprint from cert file using Node.js crypto
 function getCertFingerprint(certPath) {
@@ -33,12 +49,14 @@ function checkCertInstalledMac(certPath) {
   return new Promise((resolve) => {
     try {
       const fingerprint = getCertFingerprint(certPath).replace(/:/g, "");
-      // security verify-cert returns 0 only if cert is trusted by system policy
-      exec(`security verify-cert -c "${certPath}" -p ssl -k /Library/Keychains/System.keychain 2>/dev/null`, { windowsHide: true }, (error) => {
-        if (!error) return resolve(true);
-        // Fallback: check if fingerprint appears in System keychain with trust
-        exec(`security dump-trust-settings -d 2>/dev/null | grep -i "${fingerprint}"`, { windowsHide: true }, (err2, stdout2) => {
-          resolve(!err2 && !!stdout2?.trim());
+      // Verify exact cert bytes match — same CN with different fingerprint = stale cert
+      exec(`security find-certificate -a -c "${ROOT_CA_CN}" -Z /Library/Keychains/System.keychain 2>/dev/null`, { windowsHide: true }, (error, stdout) => {
+        if (error || !stdout) return resolve(false);
+        const match = new RegExp(`SHA-1 hash:\\s*${fingerprint}`, "i").test(stdout);
+        if (!match) return resolve(false);
+        // Cert exists with matching fingerprint — confirm trust policy
+        exec(`security verify-cert -c "${certPath}" -p ssl -k /Library/Keychains/System.keychain 2>/dev/null`, { windowsHide: true }, (err2) => {
+          resolve(!err2);
         });
       });
     } catch {
@@ -87,10 +105,7 @@ async function installCert(sudoPassword, certPath) {
 
 async function installCertMac(sudoPassword, certPath) {
   // Remove all old certs with same name first to avoid duplicate/stale cert conflict
-  const deleteOld = [
-    `security delete-certificate -c "${LEGACY_ROOT_CA_CN}" /Library/Keychains/System.keychain 2>/dev/null || true`,
-    `security delete-certificate -c "${ROOT_CA_CN}" /Library/Keychains/System.keychain 2>/dev/null || true`,
-  ].join(" && ");
+  const deleteOld = `security delete-certificate -c "9Router MITM Root CA" /Library/Keychains/System.keychain 2>/dev/null || true`;
   const install = `security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${certPath}"`;
   try {
     await execWithPassword(`${deleteOld} && ${install}`, sudoPassword);
@@ -105,7 +120,6 @@ async function installCertWindows(certPath) {
   // Auto-elevate via UAC popup if not admin (zero popup if already admin).
   // Delete any stale cert with same CN before adding to avoid duplicates.
   const script = `
-    certutil -delstore Root ${quotePs(LEGACY_ROOT_CA_CN)} 2>$null | Out-Null
     certutil -delstore Root ${quotePs(ROOT_CA_CN)} 2>$null | Out-Null
     $exit = & certutil -addstore Root ${quotePs(certPath)} 2>&1
     if ($LASTEXITCODE -ne 0) { throw "certutil exit $LASTEXITCODE" }
@@ -160,7 +174,9 @@ async function uninstallCertWindows() {
 }
 
 function checkCertInstalledLinux() {
-  return Promise.resolve(fs.existsSync(LINUX_CERT_FILE));
+  const config = getLinuxCertConfig();
+  const certFile = `${config.dir}/9router-root-ca.crt`;
+  return Promise.resolve(fs.existsSync(certFile));
 }
 
 async function updateNssDatabases(certPath, action = 'add') {
@@ -214,9 +230,13 @@ async function installCertLinux(sudoPassword, certPath) {
     await updateNssDatabases(certPath, 'add');
     return;
   }
-  const destFile = LINUX_CERT_FILE;
-  // Try update-ca-certificates (Debian/Ubuntu), fallback to update-ca-trust (Fedora/RHEL)
-  const cmd = `rm -f "${LEGACY_LINUX_CERT_FILE}" && cp "${certPath}" "${destFile}" && (update-ca-certificates 2>/dev/null || update-ca-trust 2>/dev/null || true)`;
+  
+  const config = getLinuxCertConfig();
+  const destFile = `${config.dir}/9router-root-ca.crt`;
+  
+  // Copy to the discovered directory and execute the specific update command
+  const cmd = `cp "${certPath}" "${destFile}" && (${config.cmd} 2>/dev/null || true)`;
+  
   try {
     await execWithPassword(cmd, sudoPassword);
     await updateNssDatabases(certPath, 'add');
@@ -233,7 +253,11 @@ async function uninstallCertLinux(sudoPassword) {
   if (!isSudoAvailable()) {
     return;
   }
-  const cmd = `rm -f "${LINUX_CERT_FILE}" "${LEGACY_LINUX_CERT_FILE}" && (update-ca-certificates 2>/dev/null || update-ca-trust 2>/dev/null || true)`;
+  
+  const config = getLinuxCertConfig();
+  const destFile = `${config.dir}/9router-root-ca.crt`;
+  const cmd = `rm -f "${destFile}" && (${config.cmd} 2>/dev/null || true)`;
+  
   try {
     await execWithPassword(cmd, sudoPassword);
     log("🔐 Cert: ✅ uninstalled from Linux trust store and user browser databases");

package/app/src/mitm/cert/rootCA.js

@@ -5,8 +5,6 @@ const { MITM_DIR } = require("../paths");
 
 const ROOT_CA_KEY_PATH = path.join(MITM_DIR, "rootCA.key");
 const ROOT_CA_CERT_PATH = path.join(MITM_DIR, "rootCA.crt");
-const ROOT_CA_CN = "OpenrouterX MITM Root CA";
-const ROOT_CA_ORG = "OpenrouterX";
 
 /**
  * Check if cert file is expired or expiring within 30 days
@@ -21,29 +19,18 @@ function isCertExpired(certPath) {
   }
 }
 
-function isOpenrouterXRootCA(certPath) {
-  try {
-    const cert = forge.pki.certificateFromPem(fs.readFileSync(certPath, "utf8"));
-    const cn = cert.subject.getField("CN")?.value;
-    const org = cert.subject.getField("O")?.value;
-    return cn === ROOT_CA_CN && org === ROOT_CA_ORG;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Generate Root CA certificate (only once, auto-regenerate if expired)
  * This Root CA will sign all dynamic leaf certificates
  */
 async function generateRootCA() {
   const exists = fs.existsSync(ROOT_CA_KEY_PATH) && fs.existsSync(ROOT_CA_CERT_PATH);
-  if (exists && !isCertExpired(ROOT_CA_CERT_PATH) && isOpenrouterXRootCA(ROOT_CA_CERT_PATH)) {
+  if (exists && !isCertExpired(ROOT_CA_CERT_PATH)) {
     console.log("✅ Root CA already exists");
     return { key: ROOT_CA_KEY_PATH, cert: ROOT_CA_CERT_PATH };
   }
   if (exists) {
-    console.log("🔐 Root CA expired, stale, or branded for legacy 9Router — regenerating...");
+    console.log("🔐 Root CA expired or expiring soon — regenerating...");
     try { fs.unlinkSync(ROOT_CA_KEY_PATH); } catch { /* ignore */ }
     try { fs.unlinkSync(ROOT_CA_CERT_PATH); } catch { /* ignore */ }
   }
@@ -66,8 +53,8 @@ async function generateRootCA() {
   cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 10);
 
   const attrs = [
-    { name: "commonName", value: ROOT_CA_CN },
-    { name: "organizationName", value: ROOT_CA_ORG },
+    { name: "commonName", value: "9Router MITM Root CA" },
+    { name: "organizationName", value: "9Router" },
     { name: "countryName", value: "US" }
   ];
 
@@ -182,7 +169,5 @@ module.exports = {
   generateLeafCert,
   isCertExpired,
   ROOT_CA_CERT_PATH,
-  ROOT_CA_KEY_PATH,
-  ROOT_CA_CN,
-  ROOT_CA_ORG
+  ROOT_CA_KEY_PATH
 };

package/app/src/mitm/config.js

@@ -1,16 +1,24 @@
 // All intercepted domains + URL patterns per tool
 
+const fs = require("fs");
+
 const IS_DEV = process.env.NODE_ENV === "development";
 
+// Resolve lsof absolute path — packaged apps / sudo secure_path may strip /usr/sbin from PATH
+const LSOF_BIN = (() => {
+  if (process.platform === "win32") return null;
+  for (const p of ["/usr/sbin/lsof", "/usr/bin/lsof", "/sbin/lsof"]) {
+    try { fs.accessSync(p, fs.constants.X_OK); return p; } catch { /* try next */ }
+  }
+  return "lsof"; // last-resort fallback (depends on PATH)
+})();
+
 const TARGET_HOSTS = [
   "daily-cloudcode-pa.googleapis.com",
   "cloudcode-pa.googleapis.com",
-  "daily-cloudcode-pa.sandbox.googleapis.com",
   "api.individual.githubcopilot.com",
   "q.us-east-1.amazonaws.com",
   "api2.cursor.sh",
-  "openrouter.ai",
-  "api.openrouter.ai",
 ];
 
 const URL_PATTERNS = {
@@ -18,38 +26,18 @@ const URL_PATTERNS = {
   copilot: ["/chat/completions", "/v1/messages", "/responses"],
   kiro: ["/generateAssistantResponse"],
   cursor: ["/BidiAppend", "/RunSSE", "/RunPoll", "/Run"],
-  openrouter: [
-    "/models",
-    "/api/v1/models",
-    "/api/v1/key",
-    "/api/v1/auth/key",
-    "/chat/completions",
-    "/v1/chat/completions",
-    "/api/v1/chat/completions",
-    "/v1/messages",
-    "/responses",
-    "/api/v1/responses",
-  ],
 };
 
 // Synonym map: rawModel from request → canonical alias key in mitmAlias DB
 const MODEL_SYNONYMS = {
   antigravity: {
-    "gemini-default": "gemini-3-flash",
-    "gemini-3-flash-agent": "gemini-3-flash",
-    "gemini-3.1-flash-lite": "gemini-3-flash",
-    "tab_flash_lite_preview": "gemini-3-flash",
-    "gemini-2.5-flash-lite": "gemini-3-flash",
-    "gemini-2.5-flash": "gemini-3-flash",
-    __defaults: {
-      "gemini-3.1-pro-high": "gemini-3.1-pro-high",
-      "gemini-3.1-pro-low": "gemini-3.1-pro-low",
-      "gemini-3-flash-agent": "cx/gpt-5.5",
-      "gemini-3-flash": "cx/gpt-5.5",
-      "claude-sonnet-4-6": "claude-sonnet-4-6",
-      "claude-opus-4-6-thinking": "claude-opus-4-6-thinking",
-      "gpt-oss-120b-medium": "gpt-oss-120b-medium",
-    },
+    "gemini-default": "gemini-3.5-flash-low",
+    "gemini-3.5-flash-high": "gemini-3-flash-agent",
+    "gemini-3.5-flash-medium": "gemini-3.5-flash-low",
+    "gemini-3.5-flash-extra-low": "gemini-3.5-flash-extra-low",
+    "gemini-3.1-pro-high": "gemini-pro-agent",
+    "gemini-3-pro-high": "gemini-pro-agent",
+    "gemini-3-pro-low": "gemini-3.1-pro-low",
   },
 };
 
@@ -57,15 +45,27 @@ const MODEL_SYNONYMS = {
 // Order matters: more specific patterns first. Catches AG renamed variants (e.g. gemini-pro-agent)
 const MODEL_PATTERNS = {
   antigravity: [
-    { match: /flash/i,                   alias: "gemini-3-flash" },
-    { match: /pro.*low|low.*pro/i,       alias: "gemini-3.1-pro-low" },
-    { match: /gemini.*pro|pro.*gemini/i, alias: "gemini-3.1-pro-high" },
-    { match: /opus/i,                    alias: "claude-opus-4-6-thinking" },
-    { match: /sonnet|claude/i,           alias: "claude-sonnet-4-6" },
-    { match: /gpt.*oss|oss/i,            alias: "gpt-oss-120b-medium" },
+    { match: /flash.*extra.*low|extra.*low.*flash|flash.*low|low.*flash/i, alias: "gemini-3.5-flash-extra-low" },
+    { match: /flash.*medium|medium.*flash/i,                       alias: "gemini-3.5-flash-low" },
+    { match: /flash.*agent|agent.*flash|flash/i,                   alias: "gemini-3-flash-agent" },
+    { match: /pro.*low|low.*pro/i,                                 alias: "gemini-3.1-pro-low" },
+    { match: /gemini.*pro|pro.*gemini/i,                           alias: "gemini-pro-agent" },
+    { match: /opus/i,                                              alias: "claude-opus-4-6-thinking" },
+    { match: /sonnet|claude/i,                                     alias: "claude-sonnet-4-6" },
+    { match: /gpt.*oss|oss/i,                                      alias: "gpt-oss-120b-medium" },
   ],
 };
 
+// Models that must NEVER be re-routed — always passthrough to the real upstream, even when
+// the tool's other models are mapped. Antigravity's tab-autocomplete (`tab_jump_flash_lite_preview`,
+// `tab_flash_lite_preview`, requestType tab/tab_jump) is latency-critical inline completion; routing
+// it through 9Router to an external chat model makes typing laggy and burns provider quota per
+// keystroke. Without this guard the broad `flash` pattern in MODEL_PATTERNS hijacks them onto the
+// flash-agent slot. Verified via MITM dump capture of streamGenerateContent (see AI_JOURNAL).
+const MODEL_NO_MAP = {
+  antigravity: [/^tab[_-]/i],
+};
+
 // URL substrings whose request/response should NOT be dumped to file (telemetry, polling, empty)
 const LOG_BLACKLIST_URL_PARTS = [
   "recordCodeAssistMetrics",
@@ -78,11 +78,10 @@ const LOG_BLACKLIST_URL_PARTS = [
 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" || h === "daily-cloudcode-pa.sandbox.googleapis.com") return "antigravity";
+  if (h === "daily-cloudcode-pa.googleapis.com" || h === "cloudcode-pa.googleapis.com") return "antigravity";
   if (h === "q.us-east-1.amazonaws.com") return "kiro";
   if (h === "api2.cursor.sh") return "cursor";
-  if (h === "openrouter.ai" || h === "api.openrouter.ai") return "openrouter";
   return null;
 }
 
-module.exports = { IS_DEV, TARGET_HOSTS, URL_PATTERNS, MODEL_SYNONYMS, MODEL_PATTERNS, LOG_BLACKLIST_URL_PARTS, getToolForHost };
+module.exports = { IS_DEV, LSOF_BIN, TARGET_HOSTS, URL_PATTERNS, MODEL_SYNONYMS, MODEL_PATTERNS, MODEL_NO_MAP, LOG_BLACKLIST_URL_PARTS, getToolForHost };

package/app/src/mitm/dns/dnsConfig.js

@@ -12,8 +12,8 @@ const { runElevatedPowerShell, isAdmin } = require("../winElevated.js");
  * If anything fails mid-way, restore from `.bak`. Same-volume renames are atomic on NTFS.
  */
 function atomicWriteHostsWin(target, originalContent, newContent) {
-  const tmpNew = `${target}.openrouterx.new`;
-  const tmpBak = `${target}.openrouterx.bak`;
+  const tmpNew = `${target}.9router.new`;
+  const tmpBak = `${target}.9router.bak`;
   try {
     fs.writeFileSync(tmpNew, newContent, "utf8");
     try { fs.unlinkSync(tmpBak); } catch { /* none */ }
@@ -36,48 +36,6 @@ const IS_MAC = process.platform === "darwin";
 const HOSTS_FILE = IS_WIN
   ? path.join(process.env.SystemRoot || "C:\\Windows", "System32", "drivers", "etc", "hosts")
   : "/etc/hosts";
-const MAC_PF_ANTIGRAVITY_ANCHOR = "com.apple/openrouterx-mitm-antigravity";
-const MAC_ANTIGRAVITY_FALLBACK_IPS = [
-  "216.239.32.223",
-  "216.239.34.223",
-  "216.239.36.223",
-  "216.239.38.223",
-];
-const MAC_ANTIGRAVITY_LEGACY_SHARED_IP_PREFIXES = [
-  "142.250.",
-  "142.251.",
-  "172.217.",
-];
-const REQUIRED_HOST_LOOPBACKS = IS_WIN ? ["127.0.0.1"] : ["127.0.0.1", "::1"];
-
-function isMacAntigravityPfRedirectEnabled(env = process.env) {
-  return String(env.OPENROUTERX_MITM_ANTIGRAVITY_PF || "").trim() === "1";
-}
-
-function lineHasHostEntry(line, address, host) {
-  const trimmed = String(line || "").trim();
-  if (!trimmed || trimmed.startsWith("#")) return false;
-  const parts = trimmed.split(/\s+/);
-  return parts[0] === address && parts.slice(1).includes(host);
-}
-
-function hasHostLoopback(content, host, address) {
-  return String(content || "")
-    .split(/\r?\n/)
-    .some((line) => lineHasHostEntry(line, address, host));
-}
-
-function hostHasRequiredLoopbacks(content, host, loopbacks = REQUIRED_HOST_LOOPBACKS) {
-  return loopbacks.every((address) => hasHostLoopback(content, host, address));
-}
-
-function getMissingHostsEntries(content, hosts, loopbacks = REQUIRED_HOST_LOOPBACKS) {
-  return hosts.flatMap((host) =>
-    loopbacks
-      .filter((address) => !hasHostLoopback(content, host, address))
-      .map((address) => `${address} ${host}`)
-  );
-}
 
 /** True when `sudo` exists (e.g. missing on minimal Docker images like Alpine). */
 function isSudoAvailable() {
@@ -152,111 +110,15 @@ async function flushDNS(sudoPassword) {
   }
 }
 
-function shellQuoteSingle(str) {
-  return `'${String(str).replace(/'/g, "'\\''")}'`;
-}
-
-function getDefaultMacInterface() {
-  if (!IS_MAC) return "";
-  try {
-    const out = execSync("route -n get default 2>/dev/null | awk '/interface:/{print $2; exit}'", {
-      encoding: "utf8",
-      windowsHide: true,
-    }).trim();
-    return out || "en0";
-  } catch {
-    return "en0";
-  }
-}
-
-async function getMacAntigravityRedirectIPs() {
-  return [...MAC_ANTIGRAVITY_FALLBACK_IPS];
-}
-
-function getMacLoopbackIPv4Aliases() {
-  if (!IS_MAC) return [];
-  try {
-    const out = execSync("ifconfig lo0", { encoding: "utf8", windowsHide: true });
-    return [...out.matchAll(/^\s+inet\s+(\d+\.\d+\.\d+\.\d+)\s+/gm)].map((m) => m[1]);
-  } catch {
-    return [];
-  }
-}
-
-function getMacLegacyAntigravityAliases() {
-  return getMacLoopbackIPv4Aliases().filter((ip) =>
-    MAC_ANTIGRAVITY_LEGACY_SHARED_IP_PREFIXES.some((prefix) => ip.startsWith(prefix))
-  );
-}
-
-async function enableMacAntigravityRedirect(sudoPassword) {
-  if (!IS_MAC) return;
-  if (!isMacAntigravityPfRedirectEnabled()) {
-    await disableMacAntigravityRedirect(sudoPassword);
-    log("🌐 PF antigravity: skipped (hosts-only mode; set OPENROUTERX_MITM_ANTIGRAVITY_PF=1 to opt in)");
-    return;
-  }
-  const ips = await getMacAntigravityRedirectIPs();
-  if (ips.length === 0) return;
-
-  await enableMacAntigravityLoopbackAliases(sudoPassword, ips);
-
-  const iface = getDefaultMacInterface();
-  const rules = [
-    `table <openrouterx_antigravity> persist { ${ips.join(", ")} }`,
-    `rdr pass on ${iface} inet proto tcp from any to <openrouterx_antigravity> port 443 -> 127.0.0.1 port 443`,
-    "",
-  ].join("\n");
-  const command = [
-    "pfctl -E >/dev/null 2>&1 || true",
-    `printf '%s' ${shellQuoteSingle(rules)} | pfctl -a ${shellQuoteSingle(MAC_PF_ANTIGRAVITY_ANCHOR)} -f -`,
-  ].join(" && ");
-
-  await execWithPassword(command, sudoPassword);
-  log(`🌐 PF antigravity: ✅ redirect active on ${iface} (${ips.length} IPs)`);
-}
-
-async function disableMacAntigravityRedirect(sudoPassword) {
-  if (!IS_MAC) return;
-  const ips = [...new Set([
-    ...await getMacAntigravityRedirectIPs(),
-    ...getMacLegacyAntigravityAliases(),
-  ])];
-  await execWithPassword(`pfctl -a ${shellQuoteSingle(MAC_PF_ANTIGRAVITY_ANCHOR)} -F all >/dev/null 2>&1 || true`, sudoPassword);
-  await disableMacAntigravityLoopbackAliases(sudoPassword, ips);
-  log("🌐 PF antigravity: ✅ redirect removed");
-}
-
-async function enableMacAntigravityLoopbackAliases(sudoPassword, ips) {
-  if (!IS_MAC || !ips.length) return;
-  const commands = ips.map((ip) => `ifconfig lo0 alias ${ip}/32 2>/dev/null || true`);
-  await execWithPassword(commands.join("; "), sudoPassword);
-  log(`🌐 lo0 antigravity: ✅ aliases active (${ips.length} IPs)`);
-}
-
-async function disableMacAntigravityLoopbackAliases(sudoPassword, ips) {
-  if (!IS_MAC || !ips.length) return;
-  const commands = ips.map((ip) => `ifconfig lo0 -alias ${ip} 2>/dev/null || true`);
-  await execWithPassword(commands.join("; "), sudoPassword);
-}
-
-async function ensureToolNetworkRedirect(tool, sudoPassword) {
-  if (tool === "antigravity") await enableMacAntigravityRedirect(sudoPassword);
-}
-
-async function removeToolNetworkRedirect(tool, sudoPassword) {
-  if (tool === "antigravity") await disableMacAntigravityRedirect(sudoPassword);
-}
-
 /**
  * Check if DNS entry exists for a specific host
  */
 function checkDNSEntry(host = null) {
   try {
     const hostsContent = fs.readFileSync(HOSTS_FILE, "utf8");
-    if (host) return hostHasRequiredLoopbacks(hostsContent, host);
+    if (host) return hostsContent.includes(host);
     // Legacy: check all antigravity hosts (backward compat)
-    return TOOL_HOSTS.antigravity.every(h => hostHasRequiredLoopbacks(hostsContent, h));
+    return TOOL_HOSTS.antigravity.every(h => hostsContent.includes(h));
   } catch {
     return false;
   }
@@ -270,7 +132,7 @@ function checkAllDNSStatus() {
     const hostsContent = fs.readFileSync(HOSTS_FILE, "utf8");
     const result = {};
     for (const [tool, hosts] of Object.entries(TOOL_HOSTS)) {
-      result[tool] = hosts.every(h => hostHasRequiredLoopbacks(hostsContent, h));
+      result[tool] = hosts.every(h => hostsContent.includes(h));
     }
     return result;
   } catch {
@@ -285,34 +147,31 @@ async function addDNSEntry(tool, sudoPassword) {
   const hosts = TOOL_HOSTS[tool];
   if (!hosts) throw new Error(`Unknown tool: ${tool}`);
 
-  const currentContent = fs.readFileSync(HOSTS_FILE, "utf8");
-  const entriesToAdd = getMissingHostsEntries(currentContent, hosts);
+  const entriesToAdd = hosts.filter(h => !checkDNSEntry(h));
   if (entriesToAdd.length === 0) {
     log(`🌐 DNS ${tool}: already active`);
-    await ensureToolNetworkRedirect(tool, sudoPassword);
     return;
   }
 
   try {
     if (IS_WIN) {
       // Read → trim → append → atomic write (Node-side, no CLI size limit)
-      const current = currentContent;
+      const current = fs.readFileSync(HOSTS_FILE, "utf8");
       const trimmed = current.replace(/[\r\n\s]+$/g, "");
-      const toAppend = entriesToAdd.join("\r\n");
+      const toAppend = entriesToAdd.map(h => `127.0.0.1 ${h}`).join("\r\n");
       const next = `${trimmed}\r\n${toAppend}\r\n`;
       atomicWriteHostsWin(HOSTS_FILE, current, next);
       await runElevatedPowerShell("ipconfig /flushdns | Out-Null");
     } else {
-      const current = currentContent;
+      const current = fs.readFileSync(HOSTS_FILE, "utf8");
       const trimmed = current.replace(/[\r\n\s]+$/g, "");
-      const toAppend = entriesToAdd.join("\n");
+      const toAppend = entriesToAdd.map(h => `127.0.0.1 ${h}`).join("\n");
       const next = `${trimmed}\n${toAppend}\n`;
       // Use tee via sudo to overwrite atomically — escape single quotes in content
       const escaped = next.replace(/'/g, "'\\''");
       await execWithPassword(`printf '%s' '${escaped}' | tee ${HOSTS_FILE} > /dev/null`, sudoPassword);
       await flushDNS(sudoPassword);
     }
-    await ensureToolNetworkRedirect(tool, sudoPassword);
     log(`🌐 DNS ${tool}: ✅ added ${entriesToAdd.join(", ")}`);
   } catch (error) {
     const msg = error.message?.includes("incorrect password") ? "Wrong sudo password" : `Failed to add DNS entry: ${error.message}`;
@@ -330,7 +189,6 @@ async function removeDNSEntry(tool, sudoPassword) {
   const entriesToRemove = hosts.filter(h => checkDNSEntry(h));
   if (entriesToRemove.length === 0) {
     log(`🌐 DNS ${tool}: already inactive`);
-    await removeToolNetworkRedirect(tool, sudoPassword);
     return;
   }
 
@@ -349,7 +207,6 @@ async function removeDNSEntry(tool, sudoPassword) {
       await execWithPassword(`printf '%s' '${escaped}' | tee ${HOSTS_FILE} > /dev/null`, sudoPassword);
       await flushDNS(sudoPassword);
     }
-    await removeToolNetworkRedirect(tool, sudoPassword);
     log(`🌐 DNS ${tool}: ✅ removed ${entriesToRemove.join(", ")}`);
   } catch (error) {
     const msg = error.message?.includes("incorrect password") ? "Wrong sudo password" : `Failed to remove DNS entry: ${error.message}`;
@@ -376,12 +233,6 @@ async function removeAllDNSEntries(sudoPassword) {
  */
 function removeAllDNSEntriesSync() {
   try {
-    if (IS_MAC) {
-      try { execSync(`pfctl -a ${MAC_PF_ANTIGRAVITY_ANCHOR} -F all >/dev/null 2>&1 || true`, { stdio: "ignore" }); } catch { /* ignore */ }
-      for (const ip of MAC_ANTIGRAVITY_FALLBACK_IPS) {
-        try { execSync(`ifconfig lo0 -alias ${ip} 2>/dev/null || true`, { stdio: "ignore" }); } catch { /* ignore */ }
-      }
-    }
     if (!fs.existsSync(HOSTS_FILE)) return;
     const allHosts = Object.values(TOOL_HOSTS).flat();
     const content = fs.readFileSync(HOSTS_FILE, "utf8");
@@ -412,7 +263,4 @@ module.exports = {
   isSudoPasswordRequired,
   checkDNSEntry,
   checkAllDNSStatus,
-  getMissingHostsEntries,
-  hostHasRequiredLoopbacks,
-  isMacAntigravityPfRedirectEnabled,
 };

package/app/src/mitm/handlers/antigravity.js

@@ -1,19 +1,13 @@
-const { log, err, createResponseDumper } = require("../logger");
+const { err, createResponseDumper } = require("../logger");
 const { IS_DEV } = require("../config");
 const { fetchRouter, pipeSSE } = require("./base");
 
-const NO_CREDENTIALS_MARKER = "No active credentials for provider";
-
 /**
  * Intercept Antigravity request — forward Gemini body as-is to /v1/chat/completions.
  * Router auto-detects format via body.userAgent==="antigravity" + body.request.contents,
  * runs antigravity→openai→provider→openai→antigravity translators internally.
- *
- * Graceful fallback: if Router returns 404 because no provider credentials are
- * configured, passthrough to the real upstream so Antigravity works out-of-the-box
- * without requiring a login in the Router dashboard.
  */
-async function intercept(req, res, bodyBuffer, mappedModel, passthrough) {
+async function intercept(req, res, bodyBuffer, mappedModel) {
   const dumper = IS_DEV ? createResponseDumper(req, "intercept-antigravity") : null;
   const isStream = req.url.includes(":streamGenerateContent");
   try {
@@ -21,27 +15,6 @@ async function intercept(req, res, bodyBuffer, mappedModel, passthrough) {
     if (body.model) body.model = mappedModel;
 
     const routerRes = await fetchRouter(body, "/v1/chat/completions", req.headers);
-
-    // Graceful fallback: no credentials in Router → passthrough to real upstream
-    if (routerRes.status === 404) {
-      const text = await routerRes.text();
-      if (text.includes(NO_CREDENTIALS_MARKER)) {
-        log(`⏩ passthrough | antigravity | no credentials for mapped model "${mappedModel || "unknown"}" — forwarding to real upstream`);
-        if (dumper) {
-          dumper.writeHeader(routerRes.status, Object.fromEntries(routerRes.headers));
-          dumper.writeChunk(text);
-          dumper.end();
-        }
-        return passthrough(req, res, bodyBuffer);
-      }
-      // Other 404 errors: propagate as-is
-      if (!res.headersSent) {
-        res.writeHead(404, { "Content-Type": "application/json" });
-        res.end(text);
-      }
-      return;
-    }
-
     await pipeSSE(routerRes, res, dumper);
   } catch (error) {
     err(`[antigravity] ${error.message}`);