Update dns-fix.js

dns-fix.js

@@ -1,63 +1,215 @@
+/**
+
+ * DNS fix preload script for HF Spaces.
+
+ *
+
+ * Patches Node.js dns.lookup to:
+
+ * 1. Try system DNS first
+
+ * 2. Fall back to DNS-over-HTTPS (Cloudflare) if system DNS fails
+
+ *    (This is needed because HF Spaces intercepts/blocks some domains like
+
+ *    WhatsApp web or Telegram API via standard UDP DNS).
+
+ *
+
+ * Loaded via: NODE_OPTIONS="--require /opt/dns-fix.js"
+
+ */
+
 "use strict";
 
+
+
 const dns = require("dns");
+
 const https = require("https");
 
-// 1. TELEGRAM PROXY CONFIG
-// We redirect blocked api.telegram.org to a working mirror
-const TG_PROXY_HOST = "api.telegram-proxy.org"; // You can replace this with any working TG mirror
 
-const runtimeCache = new Map();
+
+// In-memory cache for runtime DoH resolutions
+
+const runtimeCache = new Map(); // hostname -> { ip, expiry }
+
+
+
+// DNS-over-HTTPS resolver
 
 function dohResolve(hostname, callback) {
+
+  // Check runtime cache
+
   const cached = runtimeCache.get(hostname);
+
   if (cached && cached.expiry > Date.now()) {
+
     return callback(null, cached.ip);
+
   }
 
-  // Using Google DNS as it's often more stable in restricted regions
-  const url = `https://dns.google/resolve?name=${encodeURIComponent(hostname)}&type=A`;
-  
-  const req = https.get(url, { timeout: 10000 }, (res) => {
-    let body = "";
-    res.on("data", (c) => (body += c));
-    res.on("end", () => {
-      try {
-        const data = JSON.parse(body);
-        if (!data.Answer) return callback(new Error("No DNS Answer"));
-        const ip = data.Answer.find(a => a.type === 1).data;
-        runtimeCache.set(hostname, { ip, expiry: Date.now() + 600000 });
-        callback(null, ip);
-      } catch (e) {
-        callback(e);
-      }
-    });
+
+
+  const url = `https://1.1.1.1/dns-query?name=${encodeURIComponent(hostname)}&type=A`;
+
+  const req = https.get(
+
+    url,
+
+    { headers: { Accept: "application/dns-json" }, timeout: 15000 },
+
+    (res) => {
+
+      let body = "";
+
+      res.on("data", (c) => (body += c));
+
+      res.on("end", () => {
+
+        try {
+
+          const data = JSON.parse(body);
+
+          const aRecords = (data.Answer || []).filter((a) => a.type === 1);
+
+          if (aRecords.length === 0) {
+
+            return callback(new Error(`DoH: no A record for ${hostname}`));
+
+          }
+
+          const ip = aRecords[0].data;
+
+          const ttl = Math.max((aRecords[0].TTL || 300) * 1000, 60000);
+
+          runtimeCache.set(hostname, { ip, expiry: Date.now() + ttl });
+
+          callback(null, ip);
+
+        } catch (e) {
+
+          callback(new Error(`DoH parse error: ${e.message}`));
+
+        }
+
+      });
+
+    }
+
+  );
+
+  req.on("error", (e) => callback(new Error(`DoH request failed: ${e.message}`)));
+
+  req.on("timeout", () => {
+
+    req.destroy();
+
+    callback(new Error("DoH request timed out"));
+
   });
-  req.on("error", callback);
+
 }
 
+
+
+// Monkey-patch dns.lookup
+
 const origLookup = dns.lookup;
 
+
+
 dns.lookup = function patchedLookup(hostname, options, callback) {
-  if (typeof options === "function") { callback = options; options = {}; }
-  
-  // FORCE REDIRECT TELEGRAM
-  if (hostname === "api.telegram.org") {
-    console.log("⚡ Redirecting Telegram API through Proxy...");
-    return origLookup.call(dns, TG_PROXY_HOST, options, callback);
+
+  // Normalize arguments (options is optional, can be number or object)
+
+  if (typeof options === "function") {
+
+    callback = options;
+
+    options = {};
+
+  }
+
+  if (typeof options === "number") {
+
+    options = { family: options };
+
+  }
+
+  options = options || {};
+
+
+
+  // Skip patching for localhost, IPs, and internal domains
+
+  if (
+
+    !hostname ||
+
+    hostname === "localhost" ||
+
+    hostname === "0.0.0.0" ||
+
+    hostname === "127.0.0.1" ||
+
+    hostname === "::1" ||
+
+    /^\d+\.\d+\.\d+\.\d+$/.test(hostname) ||
+
+    /^::/.test(hostname)
+
+  ) {
+
+    return origLookup.call(dns, hostname, options, callback);
+
   }
 
-  // Standard Logic for other sites
+
+
+  // 1) Try system DNS first
+
   origLookup.call(dns, hostname, options, (err, address, family) => {
-    if (!err && address) return callback(null, address, family);
-    
+
+    if (!err && address) {
+
+      return callback(null, address, family);
+
+    }
+
+
+
+    // 2) System DNS failed with ENOTFOUND or EAI_AGAIN — fall back to DoH
+
     if (err && (err.code === "ENOTFOUND" || err.code === "EAI_AGAIN")) {
+
       dohResolve(hostname, (dohErr, ip) => {
-        if (dohErr) return callback(err);
+
+        if (dohErr || !ip) {
+
+          return callback(err); // Return original error
+
+        }
+
+        if (options.all) {
+
+          return callback(null, [{ address: ip, family: 4 }]);
+
+        }
+
         callback(null, ip, 4);
+
       });
+
     } else {
+
+      // Other DNS errors — pass through
+
       callback(err, address, family);
+
     }
+
   });
+
 };