@yina-npm/openrouterx 0.4.33 → 0.4.38

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

@@ -2,9 +2,7 @@ const { exec, spawn, execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
-const dns = require("dns");
 const { log, err } = require("../logger");
-const { MITM_DIR } = require("../paths");
 const { TOOL_HOSTS } = require("../../shared/constants/mitmToolHosts.js");
 const { runElevatedPowerShell, isAdmin } = require("../winElevated.js");
 
@@ -39,22 +37,23 @@ 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_REDIRECT_STATE_FILE = path.join(MITM_DIR, "antigravity-redirect-ips.json");
-const MAC_ANTIGRAVITY_DNS_SERVERS = ["8.8.8.8", "1.1.1.1"];
-const MAC_ANTIGRAVITY_DNS_TIMEOUT_MS = 1500;
+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 = [
-  "64.233.",
-  "66.102.",
-  "74.125.",
   "142.250.",
   "142.251.",
   "172.217.",
-  "172.253.",
-  "216.58.",
-  "216.239.",
 ];
 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;
@@ -170,55 +169,8 @@ function getDefaultMacInterface() {
   }
 }
 
-async function resolveIPv4WithServer(host, server) {
-  const resolver = new dns.promises.Resolver();
-  resolver.setServers([server]);
-  try {
-    return await withTimeout(resolver.resolve4(host), MAC_ANTIGRAVITY_DNS_TIMEOUT_MS);
-  } catch {
-    return [];
-  }
-}
-
-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));
-}
-
-async function getMacAntigravityRedirectIPs(hosts = TOOL_HOSTS.antigravity, servers = MAC_ANTIGRAVITY_DNS_SERVERS) {
-  if (!IS_MAC) return [];
-  const resolved = await Promise.all(
-    hosts.flatMap((host) => servers.map((server) => resolveIPv4WithServer(host, server)))
-  );
-  return [...new Set(resolved.flat())].filter((ip) => /^\d+\.\d+\.\d+\.\d+$/.test(ip));
-}
-
-function saveMacAntigravityRedirectIPs(ips) {
-  if (!IS_MAC) return;
-  try {
-    fs.mkdirSync(MITM_DIR, { recursive: true });
-    fs.writeFileSync(MAC_ANTIGRAVITY_REDIRECT_STATE_FILE, JSON.stringify({
-      ips: [...new Set(ips || [])],
-      updatedAt: new Date().toISOString(),
-    }, null, 2), "utf8");
-  } catch (e) {
-    err(`PF antigravity: failed to save redirect IP state — ${e.message}`);
-  }
-}
-
-function readMacAntigravityRedirectIPs() {
-  if (!IS_MAC) return [];
-  try {
-    const parsed = JSON.parse(fs.readFileSync(MAC_ANTIGRAVITY_REDIRECT_STATE_FILE, "utf8"));
-    return Array.isArray(parsed.ips) ? parsed.ips.filter((ip) => /^\d+\.\d+\.\d+\.\d+$/.test(ip)) : [];
-  } catch {
-    return [];
-  }
+async function getMacAntigravityRedirectIPs() {
+  return [...MAC_ANTIGRAVITY_FALLBACK_IPS];
 }
 
 function getMacLoopbackIPv4Aliases() {
@@ -239,13 +191,15 @@ function getMacLegacyAntigravityAliases() {
 
 async function enableMacAntigravityRedirect(sudoPassword) {
   if (!IS_MAC) return;
-  const ips = await getMacAntigravityRedirectIPs();
-  if (ips.length === 0) {
-    throw new Error("Could not resolve antigravity upstream IPs for PF redirect");
+  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);
-  saveMacAntigravityRedirectIPs(ips);
 
   const iface = getDefaultMacInterface();
   const rules = [
@@ -265,13 +219,11 @@ async function enableMacAntigravityRedirect(sudoPassword) {
 async function disableMacAntigravityRedirect(sudoPassword) {
   if (!IS_MAC) return;
   const ips = [...new Set([
-    ...readMacAntigravityRedirectIPs(),
     ...await getMacAntigravityRedirectIPs(),
     ...getMacLegacyAntigravityAliases(),
   ])];
   await execWithPassword(`pfctl -a ${shellQuoteSingle(MAC_PF_ANTIGRAVITY_ANCHOR)} -F all >/dev/null 2>&1 || true`, sudoPassword);
   await disableMacAntigravityLoopbackAliases(sudoPassword, ips);
-  try { fs.unlinkSync(MAC_ANTIGRAVITY_REDIRECT_STATE_FILE); } catch { /* none */ }
   log("🌐 PF antigravity: ✅ redirect removed");
 }
 
@@ -426,13 +378,9 @@ 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 [...new Set([
-        ...readMacAntigravityRedirectIPs(),
-        ...getMacLegacyAntigravityAliases(),
-      ])]) {
+      for (const ip of MAC_ANTIGRAVITY_FALLBACK_IPS) {
         try { execSync(`ifconfig lo0 -alias ${ip} 2>/dev/null || true`, { stdio: "ignore" }); } catch { /* ignore */ }
       }
-      try { fs.unlinkSync(MAC_ANTIGRAVITY_REDIRECT_STATE_FILE); } catch { /* ignore */ }
     }
     if (!fs.existsSync(HOSTS_FILE)) return;
     const allHosts = Object.values(TOOL_HOSTS).flat();
@@ -466,6 +414,5 @@ module.exports = {
   checkAllDNSStatus,
   getMissingHostsEntries,
   hostHasRequiredLoopbacks,
-  getMacAntigravityRedirectIPs,
-  readMacAntigravityRedirectIPs,
+  isMacAntigravityPfRedirectEnabled,
 };

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

@@ -1,6 +1,6 @@
 const { log, err } = require("../logger");
 
-const DEFAULT_LOCAL_ROUTER = "http://127.0.0.1:20502";
+const DEFAULT_LOCAL_ROUTER = "http://localhost:20502";
 const ROUTER_BASE = String(process.env.MITM_ROUTER_BASE || DEFAULT_LOCAL_ROUTER)
   .trim()
   .replace(/\/+$/, "") || DEFAULT_LOCAL_ROUTER;
@@ -12,34 +12,33 @@ const STRIP_HEADERS = new Set([
   "content-type", "authorization"
 ]);
 
+function normalizeRouterPath(path) {
+  const rawPath = String(path || "").trim() || "/v1/chat/completions";
+  if (rawPath === "/v1") return "/api/v1";
+  if (rawPath.startsWith("/v1/")) return `/api${rawPath}`;
+  return rawPath;
+}
+
 /**
  * Send body to OpenrouterX at the given path and return the fetch Response object.
  * Optionally forwards client headers (stripped of hop-by-hop / overridden keys).
  */
 async function fetchRouter(openaiBody, path = "/v1/chat/completions", clientHeaders = {}) {
+  const routerPath = normalizeRouterPath(path);
   const forwarded = {};
   for (const [k, v] of Object.entries(clientHeaders)) {
     if (!STRIP_HEADERS.has(k.toLowerCase())) forwarded[k] = v;
   }
 
-  let response;
-  try {
-    response = await fetch(`${ROUTER_BASE}${path}`, {
-      method: "POST",
-      headers: {
-        ...forwarded,
-        "Content-Type": "application/json",
-        ...(API_KEY && { "Authorization": `Bearer ${API_KEY}` })
-      },
-      body: JSON.stringify(openaiBody)
-    });
-  } catch (error) {
-    const cause = error.cause;
-    const causeDetail = cause
-      ? ` (cause: ${cause.code || cause.name || "unknown"}: ${cause.message || cause})`
-      : "";
-    throw new Error(`Router fetch failed for ${ROUTER_BASE}${path}: ${error.message}${causeDetail}`);
-  }
+  const response = await fetch(`${ROUTER_BASE}${routerPath}`, {
+    method: "POST",
+    headers: {
+      ...forwarded,
+      "Content-Type": "application/json",
+      ...(API_KEY && { "Authorization": `Bearer ${API_KEY}` })
+    },
+    body: JSON.stringify(openaiBody)
+  });
 
   // Forward response as-is (status + body). pipeSSE will propagate status.
   return response;
@@ -74,4 +73,4 @@ async function pipeSSE(routerRes, res, dumper) {
   }
 }
 
-module.exports = { fetchRouter, pipeSSE };
+module.exports = { fetchRouter, normalizeRouterPath, pipeSSE };

package/app/src/mitm/manager.js

@@ -16,31 +16,90 @@ const { isCertExpired } = require("./cert/rootCA");
 const { DATA_DIR, MITM_DIR } = require("./paths");
 const { log, err } = require("./logger");
 
-const DEFAULT_MITM_ROUTER_BASE = "http://127.0.0.1:20502";
-const LEGACY_DEFAULT_MITM_ROUTER_BASES = new Set([
-  "http://localhost:20128",
-  "http://127.0.0.1:20128",
-]);
+const DEFAULT_MITM_ROUTER_BASE = "http://localhost:20502";
 
 function shellQuoteSingle(str) {
   if (str == null || str === "") return "''";
   return `'${String(str).replace(/'/g, "'\\''")}'`;
 }
 
+function normalizeHttpBaseUrl(input) {
+  const raw = input == null ? "" : String(input).trim();
+  if (!raw) return "";
+  try {
+    const u = new URL(raw.replace(/\/+$/, ""));
+    if (u.protocol !== "http:" && u.protocol !== "https:") return "";
+    return u.toString().replace(/\/+$/, "");
+  } catch {
+    return "";
+  }
+}
+
+function isLoopbackBaseUrl(baseUrl) {
+  try {
+    const host = new URL(baseUrl).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function readCurrentServerBaseUrl() {
+  try {
+    const file = path.join(DATA_DIR, "server.json");
+    if (!fs.existsSync(file)) return "";
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return normalizeHttpBaseUrl(parsed && parsed.baseUrl);
+  } catch {
+    return "";
+  }
+}
+
+function canConnectBaseUrl(baseUrl, timeoutMs = 350) {
+  return new Promise((resolve) => {
+    let u;
+    try {
+      u = new URL(baseUrl);
+    } catch {
+      resolve(false);
+      return;
+    }
+
+    const port = Number(u.port || (u.protocol === "https:" ? 443 : 80));
+    const socket = net.connect({ host: u.hostname, port });
+    const done = (ok) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.setTimeout(timeoutMs, () => done(false));
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+  });
+}
+
 async function resolveMitmRouterBaseUrl() {
-  if (!_getSettings) return DEFAULT_MITM_ROUTER_BASE;
+  const currentServerBase = readCurrentServerBaseUrl();
+  if (!_getSettings) return currentServerBase || DEFAULT_MITM_ROUTER_BASE;
   try {
     const s = await _getSettings();
-    const raw = s && s.mitmRouterBaseUrl != null ? String(s.mitmRouterBaseUrl).trim() : "";
-    if (!raw) return DEFAULT_MITM_ROUTER_BASE;
-    if (LEGACY_DEFAULT_MITM_ROUTER_BASES.has(raw.replace(/\/+$/, ""))) {
-      return DEFAULT_MITM_ROUTER_BASE;
+    const configuredBase = normalizeHttpBaseUrl(s && s.mitmRouterBaseUrl);
+    if (!configuredBase) return currentServerBase || DEFAULT_MITM_ROUTER_BASE;
+
+    if (isLoopbackBaseUrl(configuredBase) && currentServerBase && configuredBase !== currentServerBase) {
+      const configuredAlive = await canConnectBaseUrl(configuredBase);
+      if (!configuredAlive && await canConnectBaseUrl(currentServerBase)) {
+        if (_updateSettings) {
+          _updateSettings({ mitmRouterBaseUrl: currentServerBase }).catch(() => { });
+        }
+        log(`🚀 MITM router base auto-corrected: ${configuredBase} → ${currentServerBase}`);
+        return currentServerBase;
+      }
     }
-    const u = new URL(raw);
-    if (u.protocol !== "http:" && u.protocol !== "https:") return DEFAULT_MITM_ROUTER_BASE;
-    return raw.replace(/\/+$/, "");
+
+    return configuredBase;
   } catch {
-    return DEFAULT_MITM_ROUTER_BASE;
+    return currentServerBase || DEFAULT_MITM_ROUTER_BASE;
   }
 }
 
@@ -405,7 +464,7 @@ async function scheduleMitmRestart(apiKey) {
       mitmIsRestarting = false;
       return;
     }
-    await startServer(apiKey, password, false, { restart: true });
+    await startServer(apiKey, password);
     log("🔄 Restarted successfully");
     mitmRestartCount = 0;
     mitmIsRestarting = false;
@@ -439,23 +498,7 @@ async function killPort443Owner(owner, sudoPassword) {
   await new Promise(r => setTimeout(r, 800));
 }
 
-async function adoptHealthyExistingServer(sudoPassword) {
-  const health = await pollMitmHealth(1000, MITM_PORT);
-  if (!health) return null;
-
-  const pid = health.pid || serverPid || (() => {
-    try { return parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10); } catch { return null; }
-  })();
-  if (pid) {
-    serverPid = pid;
-    try { fs.writeFileSync(PID_FILE, String(pid)); } catch { /* ignore */ }
-  }
-  await saveMitmSettings(true, sudoPassword);
-  return { running: true, pid: serverPid || pid };
-}
-
-async function startServer(apiKey, sudoPassword, forceKillPort443 = false, options = {}) {
-  const isRestart = options.restart === true;
+async function startServer(apiKey, sudoPassword, forceKillPort443 = false) {
   if (!serverProcess || serverProcess.killed) {
     try {
       if (fs.existsSync(PID_FILE)) {
@@ -474,13 +517,7 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false, optio
   }
 
   if (serverProcess && !serverProcess.killed) {
-    const healthy = await adoptHealthyExistingServer(sudoPassword);
-    if (healthy) return healthy;
-    if (isRestart) {
-      await killLeftoverMitm(sudoPassword);
-    } else {
-      throw new Error("MITM server is already running");
-    }
+    throw new Error("MITM server is already running");
   }
 
   await killLeftoverMitm(sudoPassword);
@@ -673,18 +710,12 @@ async function startServer(apiKey, sudoPassword, forceKillPort443 = false, optio
   const health = await pollMitmHealth(8000, MITM_PORT);
   if (!health) {
     if (serverProcess && !serverProcess.killed) { try { serverProcess.kill(); } catch { /* ignore */ } serverProcess = null; }
-    serverPid = null;
     const processUsing443 = getProcessUsingPort443();
     const portInfo = processUsing443 ? ` Port 443 already in use by ${processUsing443}.` : "";
     const reason = startError || `Check sudo password or port 443 access.${portInfo}`;
     throw new Error(`MITM server failed to start. ${reason}`);
   }
 
-  if (health.pid && health.pid !== serverPid) {
-    serverPid = health.pid;
-    try { fs.writeFileSync(PID_FILE, String(serverPid)); } catch { /* ignore */ }
-  }
-
   if (_updateSettings) await _updateSettings({ mitmCertInstalled: true }).catch(() => { });
 
   log(`✅ Server healthy (PID: ${serverPid || health.pid})`);
@@ -827,4 +858,7 @@ module.exports = {
   restoreToolDNS,
   hasDnsPrivilege,
   removeAllDNSEntriesSync,
+  resolveMitmRouterBaseUrl,
+  normalizeHttpBaseUrl,
+  readCurrentServerBaseUrl,
 };

package/app/src/mitm/server.js

@@ -344,47 +344,47 @@ async function passthrough(req, res, bodyBuffer, onResponse, transformResponse)
       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);
+      // 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;
-    }
+      if (!onResponse && !dumper && !shouldBuffer) {
+        forwardRes.pipe(res);
+        return;
+      }
 
-    const chunks = [];
-    forwardRes.on("data", chunk => {
-      if (dumper) dumper.writeChunk(chunk);
-      if (onResponse || shouldBuffer) chunks.push(chunk);
-      if (!shouldBuffer) 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));
+      const chunks = [];
+      forwardRes.on("data", chunk => {
+        if (dumper) dumper.writeChunk(chunk);
+        if (onResponse || shouldBuffer) chunks.push(chunk);
+        if (!shouldBuffer) 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");
           }
-          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();
         }
-      } else {
-        res.end();
-      }
 
-      if (dumper) dumper.end();
-      if (onResponse) try { onResponse(rawBuffer, forwardRes.headers); } catch { /* ignore */ }
-    });
+        if (dumper) dumper.end();
+        if (onResponse) try { onResponse(rawBuffer, forwardRes.headers); } catch { /* ignore */ }
+      });
     });
 
     forwardReq.on("error", (e) => {