@apocaliss92/nodelink-js 0.6.2 → 0.6.4

package/dist/{chunk-D4TKRGUP.js → chunk-UL34MR4L.js}

@@ -689,6 +689,7 @@ function readCache(uid, now) {
 }
 async function getServerBinding(uid, options = {}) {
   if (!uid || typeof uid !== "string") return void 0;
+  uid = uid.toUpperCase();
   const now = Date.now();
   const cached = readCache(uid, now);
   if (cached?.kind === "ok") return cached.response;
@@ -731,8 +732,14 @@ async function getServerBinding(uid, options = {}) {
       headers: { Accept: "application/json" }
     });
     if (!res.ok) {
+      let bodyPreview;
+      try {
+        const text = await res.text();
+        bodyPreview = text.slice(0, 512).replace(/\s+/g, " ").trim();
+      } catch {
+      }
       logger?.log?.(
-        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}`
+        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}` + (bodyPreview ? ` \u2014 body=${bodyPreview}` : "")
       );
       cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
       return void 0;
@@ -848,6 +855,68 @@ function parseServerBindingResponse(raw) {
 }
 
 // src/bcudp/BcUdpStream.ts
+async function probeEgressForHost(destHost, destPort) {
+  return await new Promise((resolve, reject) => {
+    const probe = dgram.createSocket("udp4");
+    let settled = false;
+    const finish = (err, out) => {
+      if (settled) return;
+      settled = true;
+      try {
+        probe.close();
+      } catch {
+      }
+      if (err || !out) reject(err ?? new Error("egress probe failed"));
+      else resolve(out);
+    };
+    probe.on("error", (e) => finish(e));
+    try {
+      probe.connect(destPort, destHost, () => {
+        try {
+          const a = probe.address();
+          if (typeof a === "string") return finish(new Error("probe address is string"));
+          finish(void 0, {
+            localAddress: a.address,
+            localPort: a.port
+          });
+        } catch (e) {
+          finish(e);
+        }
+      });
+    } catch (e) {
+      finish(e);
+    }
+  });
+}
+function isSameSubnetAsAnyLocalIface(destHost, srcInfo) {
+  if (!/^\d+\.\d+\.\d+\.\d+$/.test(destHost)) return "unknown";
+  const dest = destHost.split(".").map((s) => Number(s));
+  if (dest.some((n) => !Number.isFinite(n) || n < 0 || n > 255))
+    return "unknown";
+  const ifaces = networkInterfaces();
+  let ownerSubnet;
+  for (const name of Object.keys(ifaces)) {
+    const entries = ifaces[name];
+    if (!entries) continue;
+    for (const e of entries) {
+      if (e.family !== "IPv4" || e.internal) continue;
+      if (e.address !== srcInfo.localAddress) continue;
+      const addr = e.address.split(".").map((s) => Number(s));
+      const mask = e.netmask.split(".").map((s) => Number(s));
+      if (addr.length !== 4 || mask.length !== 4 || addr.some((n) => !Number.isFinite(n)) || mask.some((n) => !Number.isFinite(n)))
+        continue;
+      ownerSubnet = { addr, mask };
+      break;
+    }
+    if (ownerSubnet) break;
+  }
+  if (!ownerSubnet) return "unknown";
+  for (let i = 0; i < 4; i++) {
+    if ((ownerSubnet.addr[i] & ownerSubnet.mask[i]) !== (dest[i] & ownerSubnet.mask[i]))
+      return "mismatch";
+  }
+  return "same";
+}
 var AckLatency = class {
   currentValues = [];
   lastReceiveTime = null;
@@ -926,6 +995,16 @@ function isUnroutableForP2P(ip) {
 var P2P_LOOKUP_PORT = 9999;
 var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
+var inflightP2pLookups = /* @__PURE__ */ new Map();
+var cachedP2pLookups = /* @__PURE__ */ new Map();
+var negCachedP2pLookups = /* @__PURE__ */ new Map();
+var P2P_LOOKUP_CACHE_TTL_MS = 3e4;
+var P2P_LOOKUP_NEG_CACHE_TTL_MS = 15e3;
+function _clearP2pLookupDedupForTests() {
+  inflightP2pLookups.clear();
+  cachedP2pLookups.clear();
+  negCachedP2pLookups.clear();
+}
 var BcUdpStream = class extends EventEmitter {
   opts;
   /**
@@ -1014,31 +1093,14 @@ var BcUdpStream = class extends EventEmitter {
     });
     sock.on("error", (e) => this.emit("error", e));
     sock.on("close", () => this.emit("close"));
-    const portRange = Array.from({ length: 500 }, (_, i) => 53500 + i);
-    for (let i = portRange.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [portRange[i], portRange[j]] = [portRange[j], portRange[i]];
-    }
-    let bound = false;
-    for (const port of portRange) {
-      try {
-        await new Promise((resolve, reject) => {
-          sock.once("error", reject);
-          sock.bind(port, "0.0.0.0", () => {
-            sock.removeListener("error", reject);
-            resolve();
-          });
-        });
-        bound = true;
-        break;
-      } catch {
-      }
-    }
-    if (!bound) {
-      await new Promise(
-        (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
-      );
-    }
+    await new Promise((resolve, reject) => {
+      const onErr = (e) => reject(e);
+      sock.once("error", onErr);
+      sock.bind(0, "0.0.0.0", () => {
+        sock.removeListener("error", onErr);
+        resolve();
+      });
+    });
     if (this.opts.mode === "direct") {
       this.remote = { host: this.opts.host, port: this.opts.port };
       this.clientId = this.opts.clientId;
@@ -1109,6 +1171,49 @@ var BcUdpStream = class extends EventEmitter {
     this.remote = { host: connected.rhost, port: connected.rport };
   }
   async p2pUidLookup(sock, uid) {
+    const log = (msg) => this.discoveryLogger?.log?.(`[P2P] ${msg}`);
+    const shortUid = uid.length > 7 ? `${uid.slice(0, 5)}\u2026${uid.slice(-2)}` : uid;
+    const cached = cachedP2pLookups.get(uid);
+    if (cached && cached.expires > Date.now()) {
+      log(
+        `UID=${shortUid} cached lookup hit (relay=${cached.result.relay.ip}:${cached.result.relay.port})`
+      );
+      return cached.result;
+    }
+    const negCached = negCachedP2pLookups.get(uid);
+    if (negCached && negCached.expires > Date.now()) {
+      const remaining = negCached.expires - Date.now();
+      log(
+        `UID=${shortUid} negative-cache hit (fail-fast, retry in ${Math.ceil(remaining / 1e3)}s)`
+      );
+      throw negCached.error;
+    }
+    const inflight = inflightP2pLookups.get(uid);
+    if (inflight) {
+      log(`UID=${shortUid} sharing in-flight lookup with concurrent race lane`);
+      return await inflight;
+    }
+    const work = this._doP2pUidLookupWork(sock, uid);
+    inflightP2pLookups.set(uid, work);
+    try {
+      const result = await work;
+      cachedP2pLookups.set(uid, {
+        result,
+        expires: Date.now() + P2P_LOOKUP_CACHE_TTL_MS
+      });
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      negCachedP2pLookups.set(uid, {
+        error: err,
+        expires: Date.now() + P2P_LOOKUP_NEG_CACHE_TTL_MS
+      });
+      throw err;
+    } finally {
+      inflightP2pLookups.delete(uid);
+    }
+  }
+  async _doP2pUidLookupWork(sock, uid) {
     const log = (msg) => this.discoveryLogger?.log?.(`[P2P] ${msg}`);
     const shortUid = uid.length > 7 ? `${uid.slice(0, 5)}\u2026${uid.slice(-2)}` : uid;
     const t0 = Date.now();
@@ -1576,6 +1681,23 @@ var BcUdpStream = class extends EventEmitter {
     log(
       `local discovery: mode=${localMode} uid=${shortUid} ports=[${ports.join(", ")}] broadcasts=[${broadcastHosts.join(", ")}]${directHost ? ` direct=${directHost}` : ""} localBindPort=${localPort} timeout=${discoveryTimeout}ms`
     );
+    if (directHost && localMode === "local-direct") {
+      try {
+        const egress = await probeEgressForHost(directHost, ports[0] ?? 2015);
+        const sameSubnet = isSameSubnetAsAnyLocalIface(directHost, egress);
+        if (sameSubnet === "mismatch") {
+          log(
+            `WARN: kernel-chosen source IP ${egress.localAddress} is NOT in the same subnet as ${directHost}. Some Reolink battery cams silently drop discovery packets with off-subnet source IPs. If discovery fails, check your routing table \u2014 likely a Tailscale / VPN / secondary NIC stealing the default route.`
+          );
+        } else {
+          log(
+            `egress for ${directHost} \u2192 src=${egress.localAddress}` + (sameSubnet === "same" ? ` (same subnet \u2713)` : ` (subnet relationship unknown)`)
+          );
+        }
+      } catch (e) {
+        this.emit("debug", "egress_probe_failed", e);
+      }
+    }
     let bytesSent = 0;
     let pktsRecv = 0;
     sock.on("message", () => {
@@ -24583,7 +24705,7 @@ function selectViableUdpMethods(hasUid, methods = ALL_UDP_DISCOVERY_METHODS) {
   return methods.filter((m) => m === "local-direct");
 }
 function normalizeUid(uid) {
-  const v = uid?.trim();
+  const v = uid?.trim().toUpperCase();
   return v ? v : void 0;
 }
 function maskUid(uid) {
@@ -25304,7 +25426,10 @@ export {
   encodeHeader,
   decodeHeader,
   BaichuanFrameParser,
+  probeEgressForHost,
+  isSameSubnetAsAnyLocalIface,
   isUnroutableForP2P,
+  _clearP2pLookupDedupForTests,
   BcUdpStream,
   asLogger,
   createNullLogger,
@@ -25372,4 +25497,4 @@ export {
   tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-D4TKRGUP.js.map
+//# sourceMappingURL=chunk-UL34MR4L.js.map