@apocaliss92/nodelink-js 0.2.5 → 0.3.5

package/dist/{chunk-EG5IY3CM.js → chunk-UDS2UR4S.js}

@@ -1822,6 +1822,22 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   static coverPreviewBackoffMs = /* @__PURE__ */ new Map();
   static COVER_PREVIEW_INITIAL_BACKOFF_MS = 1e3;
   static COVER_PREVIEW_MAX_BACKOFF_MS = 3e4;
+  /**
+   * Per-client snapshot (cmd_id=109) serialization queue.
+   * 
+   * WHY: On NVR/multi-camera devices sharing one socket, concurrent snapshot requests
+   * can cause JPEG data to mix (even with per-request msgNum filtering):
+   * - Camera A and B both send frames on same socket
+   * - Frame listener is global per socket
+   * - Timing quirks can cause chunk reordering or listener confusion
+   * 
+   * FIX: Serialize all cmd_id=109 requests on THIS client instance.
+   * Each snapshot waits for previous one to complete before starting.
+   * This ensures clean frame sequences per request, zero data corruption.
+   * 
+   * Impact: Snapshots are ~0–50ms slower per camera (negligible for users).
+   */
+  snapshotQueueTail = Promise.resolve();
   opts;
   debugCfg;
   logger;
@@ -4303,6 +4319,20 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     });
   }
   async sendBinarySnapshot109(params) {
+    const prevTail = this.snapshotQueueTail;
+    let resolve;
+    const newTail = new Promise((r) => {
+      resolve = r;
+    });
+    this.snapshotQueueTail = newTail;
+    try {
+      await prevTail;
+      return await this.sendBinarySnapshot109Impl(params);
+    } finally {
+      resolve();
+    }
+  }
+  async sendBinarySnapshot109Impl(params) {
     await this.connect();
     const channel = params.channel ?? this.opts.channel ?? 0;
     const channelId = params.channelIdOverride ?? (params.channel == null ? this.hostChannelId : channel + 1);
@@ -4362,7 +4392,8 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       };
       const onFrame = (frame) => {
         if (frame.header.cmdId !== cmdId) return;
-        if (frame.header.msgNum === msgNum && frame.header.responseCode >= 400) {
+        if (frame.header.msgNum !== msgNum) return;
+        if (frame.header.responseCode >= 400) {
           fail(
             new Error(
               `Baichuan snapshot request rejected (cmdId=${cmdId} msgNum=${msgNum} responseCode=${frame.header.responseCode})`
@@ -5928,14 +5959,16 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
 `;
           }
           if (body) {
-            response += `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+            const bodyBuf = Buffer.from(body, "utf8");
+            response += `Content-Length: ${bodyBuf.length}\r
 `;
+            response += "\r\n";
+            socket.write(response);
+            socket.write(bodyBuf);
+          } else {
+            response += "\r\n";
+            socket.write(response);
           }
-          response += "\r\n";
-          if (body) {
-            response += body;
-          }
-          socket.write(response);
         };
         this.rtspDebugLog(`RTSP ${method} ${url}`);
         if (this.requireAuth) {
@@ -6145,10 +6178,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
               );
             }
           }
-          sendResponse(200, "OK", {
-            Session: sessionId,
-            Range: "npt=0.000-"
-          });
+          {
+            const baseUrl = `rtsp://${this.listenHost}:${this.listenPort}${this.path}`;
+            const resources = this.clientResources.get(clientId);
+            const rtpInfoParts = [];
+            if (resources?.setupTrack0) {
+              rtpInfoParts.push(`url=${baseUrl}/track0`);
+            }
+            if (resources?.setupTrack1) {
+              rtpInfoParts.push(`url=${baseUrl}/track1`);
+            }
+            const playHeaders = {
+              Session: sessionId,
+              Range: "npt=now-"
+            };
+            if (rtpInfoParts.length > 0) {
+              playHeaders["RTP-Info"] = rtpInfoParts.join(",");
+            }
+            sendResponse(200, "OK", playHeaders);
+          }
         } else if (method === "TEARDOWN") {
           this.logger.info(
             `[rebroadcast] TEARDOWN  client=${clientId} session=${sessionId}`
@@ -6178,6 +6226,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     sdp += `c=IN IP4 ${this.listenHost}\r
 `;
     sdp += "t=0 0\r\n";
+    sdp += "a=range:npt=now-\r\n";
+    sdp += "a=control:*\r\n";
     sdp += `m=video 0 RTP/AVP ${videoPayloadType}\r
 `;
     sdp += `a=rtpmap:${videoPayloadType} ${codec}/90000\r
@@ -7120,7 +7170,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         this.firstFramePromise = null;
         this.firstFrameResolve = null;
         this.nativeFanout = null;
-        this.prebuffer = [];
+        for (const [, resources] of this.clientResources) {
+          const res = resources;
+          res.rtpVideoBaseMicroseconds = void 0;
+          res.rtpVideoBaseTimestamp = void 0;
+          res.rtpVideoLastTimestamp = void 0;
+          res.seenFirstVideoKeyframe = false;
+          res.rtpSentVideoConfig = false;
+        }
         if (this.dedicatedSessionRelease) {
           const release = this.dedicatedSessionRelease;
           this.dedicatedSessionRelease = void 0;
@@ -15084,13 +15141,13 @@ ${stderr}`)
    */
   async muxToMp4(params) {
     const { spawn: spawn3 } = await import("child_process");
-    const { randomUUID: randomUUID2 } = await import("crypto");
+    const { randomUUID: randomUUID3 } = await import("crypto");
     const fs = await import("fs/promises");
     const os = await import("os");
     const path = await import("path");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const tmpDir = os.tmpdir();
-    const id = randomUUID2();
+    const id = randomUUID3();
     const videoFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     const videoPath = path.join(tmpDir, `reolink-${id}.${videoFormat}`);
     const outputPath = path.join(tmpDir, `reolink-${id}.mp4`);
@@ -20069,8 +20126,13 @@ ${scheduleItems}
 };
 
 // src/reolink/discovery.ts
+import { execFile } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
 import dgram3 from "dgram";
-import { networkInterfaces as networkInterfaces2 } from "os";
+import * as net3 from "net";
+import { networkInterfaces as networkInterfaces2, platform } from "os";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 async function discoverViaUdpDirect(host, options) {
   if (!options.enableUdpDiscovery) return [];
   const logger = options.logger;
@@ -20432,6 +20494,348 @@ async function discoverViaUdpBroadcast(options) {
     });
   });
 }
+var REOLINK_MAC_PREFIXES = [
+  "EC:71:DB",
+  // Most common Reolink OUI
+  "2C:1B:3A",
+  // WiFi cameras (E1 Zoom, etc.)
+  "18:2C:65",
+  // Battery cameras (Video Doorbell, Argus, etc.)
+  "DC:E5:37",
+  // Some newer models
+  "9C:8E:CD",
+  // Some WiFi models
+  "B4:4B:D6",
+  // Some models
+  "E4:3D:1A"
+  // Some models
+];
+async function discoverViaArpTable(options) {
+  if (!options.enableArpLookup) return [];
+  const logger = options.logger;
+  logger?.log?.("[Discovery] Starting ARP table lookup for Reolink MAC prefix...");
+  const discovered = [];
+  try {
+    let entries = [];
+    if (platform() === "linux") {
+      try {
+        const { readFile } = await import("fs/promises");
+        const content = await readFile("/proc/net/arp", "utf8");
+        for (const line of content.split("\n").slice(1)) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 4 && parts[0] && parts[3] && parts[3] !== "00:00:00:00:00:00") {
+            entries.push({ ip: parts[0], mac: parts[3].toUpperCase() });
+          }
+        }
+      } catch {
+        const { stdout } = await runArpCommand();
+        entries = parseArpOutput(stdout);
+      }
+    } else {
+      const { stdout } = await runArpCommand();
+      entries = parseArpOutput(stdout);
+    }
+    logger?.log?.(`[Discovery] ARP table has ${entries.length} entries`);
+    for (const { ip, mac } of entries) {
+      const isReolink = REOLINK_MAC_PREFIXES.some(
+        (prefix) => mac.startsWith(prefix)
+      );
+      if (isReolink) {
+        logger?.log?.(`[Discovery] Found Reolink device via ARP: ${ip} (MAC: ${mac})`);
+        discovered.push({
+          host: ip,
+          discoveryMethod: "arp"
+        });
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger?.warn?.(`[Discovery] ARP table lookup failed: ${msg}`);
+  }
+  logger?.log?.(`[Discovery] ARP lookup complete. Found ${discovered.length} device(s).`);
+  return discovered;
+}
+async function runArpCommand() {
+  const paths = ["/usr/sbin/arp", "/sbin/arp", "/usr/bin/arp", "arp"];
+  for (const arpPath of paths) {
+    try {
+      return await execFileAsync(arpPath, ["-an"], { timeout: 5e3 });
+    } catch {
+    }
+  }
+  throw new Error("arp command not found");
+}
+function parseArpOutput(stdout) {
+  const results = [];
+  for (const line of stdout.split("\n")) {
+    const match = /\((\d+\.\d+\.\d+\.\d+)\)\s+at\s+([0-9a-fA-F:]+)/i.exec(line);
+    if (match && match[1] && match[2] && match[2] !== "(incomplete)") {
+      results.push({ ip: match[1], mac: match[2].toUpperCase() });
+    }
+  }
+  return results;
+}
+async function discoverViaDhcpListener(options) {
+  if (!options.enableDhcpListener) return [];
+  const logger = options.logger;
+  const timeoutMs = options.dhcpListenerTimeoutMs ?? 1e4;
+  logger?.log?.(`[Discovery] Starting passive DHCP listener (${timeoutMs}ms)...`);
+  const discovered = /* @__PURE__ */ new Map();
+  return new Promise((resolve) => {
+    let socket;
+    let timeout;
+    try {
+      socket = dgram3.createSocket({ type: "udp4", reuseAddr: true });
+    } catch (err) {
+      logger?.warn?.(`[Discovery] DHCP: failed to create socket: ${err instanceof Error ? err.message : String(err)}`);
+      resolve([]);
+      return;
+    }
+    socket.on("message", (msg) => {
+      try {
+        if (msg.length < 240) return;
+        const op = msg[0];
+        const hlen = msg[2];
+        if (hlen !== 6) return;
+        const mac = [
+          msg[28]?.toString(16).padStart(2, "0"),
+          msg[29]?.toString(16).padStart(2, "0"),
+          msg[30]?.toString(16).padStart(2, "0"),
+          msg[31]?.toString(16).padStart(2, "0"),
+          msg[32]?.toString(16).padStart(2, "0"),
+          msg[33]?.toString(16).padStart(2, "0")
+        ].join(":").toUpperCase();
+        const isReolinkMac = REOLINK_MAC_PREFIXES.some((p) => mac.startsWith(p));
+        let hostname = "";
+        let i = 240;
+        while (i < msg.length - 1) {
+          const optType = msg[i];
+          if (optType === 255) break;
+          if (optType === 0) {
+            i++;
+            continue;
+          }
+          const optLen = msg[i + 1] ?? 0;
+          if (optType === 12 && optLen > 0) {
+            hostname = msg.subarray(i + 2, i + 2 + optLen).toString("ascii").toLowerCase();
+          }
+          i += 2 + optLen;
+        }
+        const isReolinkHostname = hostname.startsWith("reolink");
+        if (!isReolinkMac && !isReolinkHostname) return;
+        const yiaddr = `${msg[16]}.${msg[17]}.${msg[18]}.${msg[19]}`;
+        const ciaddr = `${msg[12]}.${msg[13]}.${msg[14]}.${msg[15]}`;
+        const ip = yiaddr !== "0.0.0.0" ? yiaddr : ciaddr;
+        if (ip === "0.0.0.0" || !ip) return;
+        if (!discovered.has(ip)) {
+          logger?.log?.(`[Discovery] DHCP: found Reolink device ${ip} (MAC: ${mac}, hostname: ${hostname || "n/a"}, op: ${op === 1 ? "request" : "reply"})`);
+          const device = {
+            host: ip,
+            discoveryMethod: "dhcp"
+          };
+          if (hostname) device.name = hostname;
+          discovered.set(ip, device);
+        }
+      } catch {
+      }
+    });
+    socket.on("error", (err) => {
+      logger?.warn?.(`[Discovery] DHCP socket error: ${err.message}`);
+      clearTimeout(timeout);
+      socket.close();
+      resolve(Array.from(discovered.values()));
+    });
+    socket.bind(67, "0.0.0.0", () => {
+      logger?.log?.("[Discovery] DHCP listener bound on port 67");
+      timeout = setTimeout(() => {
+        socket.close();
+        logger?.log?.(`[Discovery] DHCP listener complete. Found ${discovered.size} device(s).`);
+        resolve(Array.from(discovered.values()));
+      }, timeoutMs);
+    });
+  });
+}
+function probeTcpPort(ip, port, timeoutMs) {
+  return new Promise((resolve) => {
+    const socket = new net3.Socket();
+    let settled = false;
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.on("connect", () => done(true));
+    socket.on("timeout", () => done(false));
+    socket.on("error", () => done(false));
+    socket.connect(port, ip);
+  });
+}
+async function discoverViaTcpPortScan(options) {
+  if (!options.enableTcpPortScan) return [];
+  const logger = options.logger;
+  const networkCidr = options.networkCidr ?? getLocalNetworks()[0];
+  const timeoutMs = options.tcpProbeTimeoutMs ?? 1500;
+  const maxConcurrent = options.maxConcurrentProbes ?? 80;
+  if (!networkCidr) {
+    logger?.warn?.("[Discovery] No network CIDR available for TCP port scan");
+    return [];
+  }
+  logger?.log?.(`[Discovery] Starting TCP port 9000 scan on network ${networkCidr}...`);
+  const ipRange = parseCidr(networkCidr);
+  if (!ipRange) {
+    logger?.warn?.(`[Discovery] Invalid CIDR: ${networkCidr}`);
+    return [];
+  }
+  const discovered = [];
+  const ipAddresses = [];
+  for (let ipNum = ipRange.start; ipNum <= ipRange.end && ipNum <= ipRange.start + 254; ipNum++) {
+    ipAddresses.push(ipNumberToString(ipNum));
+  }
+  logger?.log?.(`[Discovery] Scanning ${ipAddresses.length} IPs on port 9000...`);
+  for (let i = 0; i < ipAddresses.length; i += maxConcurrent) {
+    const batch = ipAddresses.slice(i, i + maxConcurrent);
+    const batchResults = await Promise.allSettled(
+      batch.map(async (ip) => {
+        const open = await probeTcpPort(ip, 9e3, timeoutMs);
+        if (open) {
+          logger?.log?.(`[Discovery] Found Baichuan device at ${ip}:9000`);
+          return { host: ip, discoveryMethod: "tcp_port_scan" };
+        }
+        return null;
+      })
+    );
+    for (const result of batchResults) {
+      if (result.status === "fulfilled" && result.value) {
+        discovered.push(result.value);
+      }
+    }
+  }
+  logger?.log?.(`[Discovery] TCP port scan complete. Found ${discovered.length} device(s).`);
+  return discovered;
+}
+async function discoverViaOnvif(options) {
+  if (!options.enableOnvifDiscovery) return [];
+  const logger = options.logger;
+  const timeoutMs = options.onvifDiscoveryTimeoutMs ?? 5e3;
+  logger?.log?.(`[Discovery] Starting ONVIF WS-Discovery (${timeoutMs}ms)...`);
+  const discovered = /* @__PURE__ */ new Map();
+  const MULTICAST_ADDR = "239.255.255.250";
+  const MULTICAST_PORT = 3702;
+  const messageId = `uuid:${randomUUID2()}`;
+  const probeMessage = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope"',
+    '  xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing"',
+    '  xmlns:d="http://schemas.xmlsoap.org/ws/2005/04/discovery"',
+    '  xmlns:dn="http://www.onvif.org/ver10/network/wsdl">',
+    "  <s:Header>",
+    `    <a:MessageID>${messageId}</a:MessageID>`,
+    "    <a:To>urn:schemas-xmlsoap-org:ws:2005:04:discovery</a:To>",
+    "    <a:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</a:Action>",
+    "  </s:Header>",
+    "  <s:Body>",
+    "    <d:Probe>",
+    "      <d:Types>dn:NetworkVideoTransmitter</d:Types>",
+    "    </d:Probe>",
+    "  </s:Body>",
+    "</s:Envelope>"
+  ].join("\n");
+  return new Promise((resolve) => {
+    const socket = dgram3.createSocket({ type: "udp4", reuseAddr: true });
+    let timeout;
+    socket.on("message", (msg, rinfo) => {
+      try {
+        const xml = msg.toString("utf8");
+        const xaddrsMatch = /<[^:]*:?XAddrs>([^<]+)<\/[^:]*:?XAddrs>/i.exec(xml);
+        const scopesMatch = /<[^:]*:?Scopes>([^<]+)<\/[^:]*:?Scopes>/i.exec(xml);
+        let host = rinfo.address;
+        let httpPort;
+        if (xaddrsMatch?.[1]) {
+          const urls = xaddrsMatch[1].trim().split(/\s+/);
+          for (const url of urls) {
+            try {
+              const parsed = new URL(url);
+              if (parsed.hostname) {
+                host = parsed.hostname;
+                const p = Number.parseInt(parsed.port, 10);
+                if (p && p !== 80) httpPort = p;
+                break;
+              }
+            } catch {
+            }
+          }
+        }
+        if (discovered.has(host)) return;
+        let model;
+        let name;
+        let manufacturer;
+        if (scopesMatch?.[1]) {
+          const scopes = scopesMatch[1].trim().split(/\s+/);
+          for (const scope of scopes) {
+            const hwMatch = /\/hardware\/(.+)$/i.exec(scope);
+            if (hwMatch?.[1]) model = decodeURIComponent(hwMatch[1]);
+            const nameMatch = /\/name\/(.+)$/i.exec(scope);
+            if (nameMatch?.[1]) name = decodeURIComponent(nameMatch[1]);
+            const mfgMatch = /\/manufacturer\/(.+)$/i.exec(scope);
+            if (mfgMatch?.[1]) manufacturer = decodeURIComponent(mfgMatch[1]);
+          }
+        }
+        const allText = `${manufacturer ?? ""} ${model ?? ""} ${xaddrsMatch?.[1] ?? ""}`.toLowerCase();
+        const hasReolinkText = allText.includes("reolink");
+        const hasReolinkModel = /^(rlc|rln|rl[ncb]|e1|cw|cx|duo|trackmix|argus|lumus|go|video doorbell|reolink)/i.test(model ?? "");
+        const isReolink = hasReolinkText || hasReolinkModel;
+        if (!isReolink) {
+          logger?.debug?.(`[Discovery] ONVIF: skipping non-Reolink device at ${host} (${model ?? "unknown"}, manufacturer: ${manufacturer ?? "unknown"})`);
+          return;
+        }
+        logger?.log?.(`[Discovery] ONVIF: found Reolink device at ${host}${model ? ` (${model})` : ""}${name ? ` name="${name}"` : ""}`);
+        const device = {
+          host,
+          discoveryMethod: "onvif"
+        };
+        if (model) device.model = model;
+        if (name && name !== "IPC") {
+          device.name = name;
+        } else if (model) {
+          device.name = model;
+        }
+        if (httpPort) device.httpPort = httpPort;
+        discovered.set(host, device);
+      } catch {
+      }
+    });
+    socket.on("error", (err) => {
+      logger?.warn?.(`[Discovery] ONVIF socket error: ${err.message}`);
+    });
+    socket.bind(0, "0.0.0.0", () => {
+      const buf = Buffer.from(probeMessage, "utf8");
+      socket.send(buf, 0, buf.length, MULTICAST_PORT, MULTICAST_ADDR, (err) => {
+        if (err) {
+          logger?.warn?.(`[Discovery] ONVIF: failed to send probe: ${err.message}`);
+        }
+      });
+      setTimeout(() => {
+        try {
+          socket.send(buf, 0, buf.length, MULTICAST_PORT, MULTICAST_ADDR);
+        } catch {
+        }
+      }, 500);
+      timeout = setTimeout(() => {
+        try {
+          socket.close();
+        } catch {
+        }
+        logger?.log?.(`[Discovery] ONVIF WS-Discovery complete. Found ${discovered.size} device(s).`);
+        resolve(Array.from(discovered.values()));
+      }, timeoutMs);
+    });
+    socket.on("close", () => {
+      if (timeout) clearTimeout(timeout);
+    });
+  });
+}
 async function discoverReolinkDevices(options = {}) {
   const logger = options.logger;
   logger?.log?.("[Discovery] Starting Reolink device discovery...");
@@ -20454,10 +20858,26 @@ async function discoverReolinkDevices(options = {}) {
       results.push(seenDevices.get(key));
     }
   };
-  const [httpDevices, udpDevices] = await Promise.all([
+  const [httpDevices, udpDevices, tcpDevices, arpDevices, dhcpDevices, onvifDevices] = await Promise.all([
     discoverViaHttpScan(options),
-    discoverViaUdpBroadcast(options)
+    discoverViaUdpBroadcast(options),
+    discoverViaTcpPortScan(options),
+    discoverViaArpTable(options),
+    discoverViaDhcpListener(options),
+    discoverViaOnvif(options)
   ]);
+  for (const device of dhcpDevices) {
+    mergeDevice(device);
+  }
+  for (const device of arpDevices) {
+    mergeDevice(device);
+  }
+  for (const device of tcpDevices) {
+    mergeDevice(device);
+  }
+  for (const device of onvifDevices) {
+    mergeDevice(device);
+  }
   for (const device of httpDevices) {
     mergeDevice(device);
   }
@@ -20534,8 +20954,8 @@ function isTcpFailureThatShouldFallbackToUdp(e) {
 async function pingHost(host, timeoutMs = 3e3) {
   return new Promise((resolve) => {
     const { exec } = __require("child_process");
-    const platform = process.platform;
-    const pingCmd = platform === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform === "darwin" ? (
+    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}`
     ) : (
@@ -21076,10 +21496,14 @@ export {
   discoverViaUdpDirect,
   discoverViaHttpScan,
   discoverViaUdpBroadcast,
+  discoverViaArpTable,
+  discoverViaDhcpListener,
+  discoverViaTcpPortScan,
+  discoverViaOnvif,
   discoverReolinkDevices,
   normalizeUid,
   maskUid,
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-EG5IY3CM.js.map
+//# sourceMappingURL=chunk-UDS2UR4S.js.map