@apocaliss92/nodelink-js 0.5.1-beta.1 → 0.5.1-beta.11

package/dist/{DiagnosticsTools-ILDDJZL7.js → DiagnosticsTools-7BIWJDZS.js}

@@ -12,7 +12,7 @@ import {
   sampleStreams,
   sanitizeFixtureData,
   testChannelStreams
-} from "./chunk-AHY4L7JI.js";
+} from "./chunk-VOPEOB4H.js";
 import "./chunk-GVWJGQPT.js";
 export {
   captureModelFixtures,
@@ -29,4 +29,4 @@ export {
   sanitizeFixtureData,
   testChannelStreams
 };
-//# sourceMappingURL=DiagnosticsTools-ILDDJZL7.js.map
+//# sourceMappingURL=DiagnosticsTools-7BIWJDZS.js.map

package/dist/{chunk-6ILAHQF5.js → chunk-COUH6ZJT.js}

@@ -30,7 +30,7 @@ import {
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
   xmlEscape
-} from "./chunk-AHY4L7JI.js";
+} from "./chunk-VOPEOB4H.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -656,6 +656,10 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 var P2P_RELAY_HOSTNAMES = [
+  // Master anycast routers — try first.
+  "p2pm-abr.reolink.com",
+  "p2pm-ali.reolink.com",
+  // Numbered regional relays.
   "p2p.reolink.com",
   "p2p1.reolink.com",
   "p2p2.reolink.com",
@@ -667,8 +671,29 @@ var P2P_RELAY_HOSTNAMES = [
   "p2p8.reolink.com",
   "p2p9.reolink.com",
   "p2p10.reolink.com",
-  "p2p11.reolink.com"
+  "p2p11.reolink.com",
+  // China-region fallbacks (intentionally last).
+  "p2p.reolink.com.cn",
+  "p2p1.reolink.com.cn",
+  "p2p2.reolink.com.cn",
+  "p2p3.reolink.com.cn",
+  "p2p4.reolink.com.cn",
+  "p2p5.reolink.com.cn",
+  "p2p6.reolink.com.cn",
+  "p2p7.reolink.com.cn",
+  "p2p8.reolink.com.cn",
+  "p2p9.reolink.com.cn"
 ];
+function isUnroutableForP2P(ip) {
+  if (!ip) return true;
+  if (ip === "0.0.0.0") return true;
+  if (ip.startsWith("127.")) return true;
+  if (ip.startsWith("10.")) return true;
+  if (ip.startsWith("192.168.")) return true;
+  if (/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ip)) return true;
+  if (/^100\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\./.test(ip)) return true;
+  return false;
+}
 var P2P_LOOKUP_PORT = 9999;
 var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
@@ -835,19 +860,30 @@ var BcUdpStream = class extends EventEmitter {
   }
   async p2pUidLookup(sock, uid) {
     const resolved = [];
+    const sinkholed = [];
     for (const host of P2P_RELAY_HOSTNAMES) {
       try {
         const answers = await dns.lookup(host, { family: 4, all: true });
         for (const a of answers) {
-          if (a.address && !resolved.includes(a.address))
-            resolved.push(a.address);
+          if (!a.address) continue;
+          if (isUnroutableForP2P(a.address)) {
+            sinkholed.push({ host, ip: a.address });
+            continue;
+          }
+          if (!resolved.includes(a.address)) resolved.push(a.address);
         }
       } catch {
       }
     }
     if (resolved.length === 0) {
+      if (sinkholed.length > 0) {
+        const samples = sinkholed.slice(0, 3).map((s) => `${s.host} \u2192 ${s.ip}`).join(", ");
+        throw new Error(
+          `P2P UID lookup failed: DNS resolves Reolink P2P hostnames to non-routable IPs (${samples}). This is almost certainly an /etc/hosts rewrite or a DNS filter (Pi-hole, AdGuard, NextDNS) blocking *.reolink.com. Battery cameras cannot connect without P2P \u2014 whitelist *.reolink.com (at least p2p*.reolink.com on UDP/9999) or remove the override. Verify with \`getent hosts p2p.reolink.com\` inside your container \u2014 if it differs from \`nslookup p2p.reolink.com\`, the offender is /etc/hosts.`
+        );
+      }
       throw new Error(
-        "P2P UID lookup failed: no p2p.reolink.com addresses resolved"
+        "P2P UID lookup failed: no p2p.reolink.com addresses resolved (DNS failure)"
       );
     }
     const start = Date.now();
@@ -19771,6 +19807,37 @@ ${xml}`
         }
       );
     }
+    if (!isMultiFocal) {
+      try {
+        const caps = await this.getDeviceCapabilities(channel);
+        const channelNumRaw = caps.support?.channelNum;
+        const channelNum = typeof channelNumRaw === "string" ? Number.parseInt(channelNumRaw, 10) : channelNumRaw;
+        if (Number.isFinite(channelNum) && channelNum >= 2) {
+          isMultiFocal = true;
+        }
+        if (!isMultiFocal) {
+          const items = caps.support?.items;
+          if (Array.isArray(items)) {
+            for (const it of items) {
+              const raw = it.binoCfg;
+              const v = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : 0;
+              if (Number.isFinite(v) && v > 0) {
+                isMultiFocal = true;
+                break;
+              }
+            }
+          }
+        }
+      } catch (e) {
+        logDebug(
+          "[ReolinkBaichuanApi] buildVideoStreamOptions: SupportInfo dual-lens probe failed",
+          {
+            host: this.host,
+            err: e instanceof Error ? e.message : String(e)
+          }
+        );
+      }
+    }
     logDebug("[ReolinkBaichuanApi] buildVideoStreamOptions: inputs", {
       host: this.host,
       onNvr,
@@ -20165,7 +20232,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-ILDDJZL7.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-7BIWJDZS.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -20181,7 +20248,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-ILDDJZL7.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-7BIWJDZS.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -24231,19 +24298,95 @@ function isTcpFailureThatShouldFallbackToUdp(e) {
   return message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("EHOSTUNREACH") || message.includes("ENETUNREACH") || message.includes("socket hang up") || message.includes("TCP connection timeout") || message.includes("Baichuan socket closed") || message.includes("timeout waiting for nonce") || message.includes("expected encryption info") || message.includes("ECONNRESET") || message.includes("EPIPE");
 }
 async function pingHost(host, timeoutMs = 3e3) {
-  const { exec } = await import("child_process");
+  if (!host || typeof host !== "string") return false;
   const platform2 = process.platform;
-  const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "darwin" ? (
-    // macOS: -W is in milliseconds (Linux: seconds)
-    `ping -c 1 -W ${timeoutMs} ${host}`
-  ) : (
-    // Linux/BSD-ish: -W is in seconds on most distros
-    `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`
-  );
+  const pingCandidates = platform2 === "win32" ? ["ping"] : platform2 === "darwin" ? ["/sbin/ping", "/usr/sbin/ping", "ping"] : ["/bin/ping", "/usr/bin/ping", "ping"];
+  const pingArgs = (bin) => {
+    void bin;
+    if (platform2 === "win32") {
+      return ["-n", "1", "-w", String(timeoutMs), host];
+    }
+    if (platform2 === "darwin") {
+      return ["-c", "1", "-W", String(timeoutMs), host];
+    }
+    return ["-c", "1", "-W", String(Math.max(1, Math.floor(timeoutMs / 1e3))), host];
+  };
+  const { spawn: spawn3 } = await import("child_process");
+  for (const bin of pingCandidates) {
+    const ranOk = await new Promise((resolve) => {
+      let settled = false;
+      let child;
+      try {
+        child = spawn3(bin, pingArgs(bin), { stdio: "ignore" });
+      } catch {
+        resolve("spawn-failed");
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          child?.kill("SIGKILL");
+        } catch {
+        }
+        resolve(false);
+      }, timeoutMs + 500);
+      child.on("error", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve("spawn-failed");
+      });
+      child.on("exit", (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve(code === 0);
+      });
+    });
+    if (ranOk === true) return true;
+    if (ranOk === "spawn-failed") continue;
+    break;
+  }
+  for (const port of [9e3, 443, 80]) {
+    if (await tcpReachabilityProbe(host, port, 800)) return true;
+  }
+  return false;
+}
+async function tcpReachabilityProbe(host, port, timeoutMs) {
+  const net4 = await import("net");
   return new Promise((resolve) => {
-    exec(pingCmd, (error) => {
-      resolve(!error);
+    let settled = false;
+    const socket = new net4.Socket();
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(false);
+    }, timeoutMs);
+    const finish = (reachable) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(reachable);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", (err) => {
+      if (err?.code === "ECONNREFUSED") finish(true);
+      else finish(false);
     });
+    try {
+      socket.connect(port, host);
+    } catch {
+      finish(false);
+    }
   });
 }
 function createBaichuanApi(inputs, transport) {
@@ -24759,6 +24902,7 @@ export {
   encodeHeader,
   decodeHeader,
   BaichuanFrameParser,
+  isUnroutableForP2P,
   BcUdpStream,
   asLogger,
   createNullLogger,
@@ -24823,6 +24967,7 @@ export {
   normalizeUid,
   maskUid,
   isTcpFailureThatShouldFallbackToUdp,
+  tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-6ILAHQF5.js.map
+//# sourceMappingURL=chunk-COUH6ZJT.js.map