@apocaliss92/nodelink-js 0.6.0 → 0.6.2

package/dist/cli/rtsp-server.cjs

@@ -2574,6 +2574,41 @@ var init_BaichuanVideoStream = __esm({
 });
 
 // src/protocol/xml.ts
+function xmlTextRe(tag) {
+  let re = xmlTextReCache.get(tag);
+  if (re === void 0) {
+    re = new RegExp(`<${tag}>([^<]*)</${tag}>`);
+    xmlTextReCache.set(tag, re);
+  }
+  return re;
+}
+function xmlTagRe(tag) {
+  let re = xmlTagReCache.get(tag);
+  if (re === void 0) {
+    re = new RegExp(`<${tag}>[^<]*</${tag}>`);
+    xmlTagReCache.set(tag, re);
+  }
+  return re;
+}
+function xmlNestedRe(parent, child) {
+  const key = `${parent}\0${child}`;
+  let re = xmlNestedReCache.get(key);
+  if (re === void 0) {
+    re = new RegExp(
+      `(<${parent}[^>]*>[\\s\\S]*?<${child}>)[^<]*(</${child}>[\\s\\S]*?</${parent}>)`
+    );
+    xmlNestedReCache.set(key, re);
+  }
+  return re;
+}
+function xmlStreamBlockRe(streamTag) {
+  let re = xmlStreamBlockReCache.get(streamTag);
+  if (re === void 0) {
+    re = new RegExp(`(<${streamTag}[^>]*>)([\\s\\S]*?)(</${streamTag}>)`);
+    xmlStreamBlockReCache.set(streamTag, re);
+  }
+  return re;
+}
 function xmlEscape(text) {
   if (text === void 0 || text === null || typeof text !== "string") {
     const error = new Error(
@@ -2694,8 +2729,7 @@ function buildPreviewStopXmlV11(params) {
 </body>`;
 }
 function getXmlText(xml, tagName) {
-  const re = new RegExp(`<${tagName}>([^<]*)</${tagName}>`);
-  const m = re.exec(xml);
+  const m = xmlTextRe(tagName).exec(xml);
   return m?.[1];
 }
 function buildPtzControlXml(channelId, command, speed) {
@@ -2796,13 +2830,12 @@ ${xml}`;
 function applyXmlTagPatch(xml, tag, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
-  const re = new RegExp(`<${tag}>[^<]*</${tag}>`);
-  return xml.replace(re, `<${tag}>${v}</${tag}>`);
+  return xml.replace(xmlTagRe(tag), `<${tag}>${v}</${tag}>`);
 }
 function upsertXmlTag(xml, tag, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
-  const re = new RegExp(`<${tag}>[^<]*</${tag}>`);
+  const re = xmlTagRe(tag);
   if (re.test(xml)) {
     return xml.replace(re, `<${tag}>${v}</${tag}>`);
   }
@@ -2811,16 +2844,11 @@ function upsertXmlTag(xml, tag, value) {
 function patchNestedTag(xml, parent, child, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
-  const re = new RegExp(
-    `(<${parent}[^>]*>[\\s\\S]*?<${child}>)[^<]*(</${child}>[\\s\\S]*?</${parent}>)`
-  );
-  return xml.replace(re, `$1${v}$2`);
+  return xml.replace(xmlNestedRe(parent, child), `$1${v}$2`);
 }
 function applyStreamPatch(xml, streamTag, patch) {
   if (!patch) return xml;
-  const re = new RegExp(
-    `(<${streamTag}[^>]*>)([\\s\\S]*?)(</${streamTag}>)`
-  );
+  const re = xmlStreamBlockRe(streamTag);
   return xml.replace(re, (_match, open, body, close) => {
     let next = body;
     if (patch.audio !== void 0) {
@@ -2850,10 +2878,9 @@ function applyStreamPatch(xml, streamTag, patch) {
       next = upsertXmlTag(next, "encoderProfile", patch.encoderProfile);
     }
     if (patch.gop !== void 0) {
-      const gopBlockRe = /(<gop[^>]*>)([\s\S]*?)(<\/gop>)/;
-      if (gopBlockRe.test(next)) {
+      if (GOP_BLOCK_RE.test(next)) {
         next = next.replace(
-          gopBlockRe,
+          GOP_BLOCK_RE,
           (_m, gOpen, gBody, gClose) => `${gOpen}${applyXmlTagPatch(gBody, "cur", patch.gop)}${gClose}`
         );
       } else {
@@ -2882,10 +2909,15 @@ function buildAbilityInfoExtensionXml(username) {
 <token>system, streaming, PTZ, IO, security, replay, disk, network, alarm, record, video, image</token>
 </Extension>`;
 }
-var XML_HEADER;
+var xmlTextReCache, xmlTagReCache, xmlNestedReCache, GOP_BLOCK_RE, xmlStreamBlockReCache, XML_HEADER;
 var init_xml = __esm({
   "src/protocol/xml.ts"() {
     "use strict";
+    xmlTextReCache = /* @__PURE__ */ new Map();
+    xmlTagReCache = /* @__PURE__ */ new Map();
+    xmlNestedReCache = /* @__PURE__ */ new Map();
+    GOP_BLOCK_RE = /(<gop[^>]*>)([\s\S]*?)(<\/gop>)/;
+    xmlStreamBlockReCache = /* @__PURE__ */ new Map();
     XML_HEADER = `<?xml version="1.0" encoding="UTF-8" ?>`;
   }
 });
@@ -11318,12 +11350,28 @@ async function getServerBinding(uid, options = {}) {
   const fetchImpl = options.fetchImpl ?? globalThis.fetch;
   const logger = options.logger;
   if (typeof fetchImpl !== "function") {
-    logger?.debug?.(
+    logger?.log?.(
       `[server-binding] global fetch unavailable; skipping cloud lookup`
     );
     cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
     return void 0;
   }
+  try {
+    const apiHostname = new URL(baseUrl).hostname;
+    const dns2 = await import("dns/promises");
+    const answers = await dns2.lookup(apiHostname, { family: 4, all: true });
+    const sinkholed = answers.find(
+      (a) => a.address?.startsWith("127.") || a.address === "0.0.0.0" || a.address?.startsWith("10.") || a.address?.startsWith("192.168.") || /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(a.address ?? "")
+    );
+    if (sinkholed) {
+      logger?.log?.(
+        `[server-binding] ${uid}: DNS for ${apiHostname} resolves to ${sinkholed.address} (sinkhole / /etc/hosts override). Cloud directory unreachable \u2014 falling back to the 22-hostname P2P sweep. Whitelist ${apiHostname} to enable.`
+      );
+      cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
+      return void 0;
+    }
+  } catch {
+  }
   const url = `${baseUrl}/devices/${encodeURIComponent(uid)}/server-binding?language=${encodeURIComponent(language)}`;
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -11334,8 +11382,8 @@ async function getServerBinding(uid, options = {}) {
       headers: { Accept: "application/json" }
     });
     if (!res.ok) {
-      logger?.debug?.(
-        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText}`
+      logger?.log?.(
+        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}`
       );
       cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
       return void 0;
@@ -11343,8 +11391,15 @@ async function getServerBinding(uid, options = {}) {
     const json = await res.json();
     const parsed = parseServerBindingResponse(json);
     if (!parsed) {
-      logger?.debug?.(
-        `[server-binding] ${uid}: response shape did not match expectations`
+      logger?.log?.(
+        `[server-binding] ${uid}: response shape did not match expectations (Reolink schema change?)`
+      );
+      cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
+      return void 0;
+    }
+    if (parsed.availableZones.length === 0) {
+      logger?.log?.(
+        `[server-binding] ${uid}: cloud returned 0 zones \u2014 UID not registered with Reolink cloud (or wrong region)`
       );
       cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
       return void 0;
@@ -11363,9 +11418,23 @@ async function getServerBinding(uid, options = {}) {
     );
     return parsed;
   } catch (e) {
-    logger?.debug?.(
-      `[server-binding] ${uid}: ${e?.message ?? String(e)}`
-    );
+    const msg = e?.message ?? String(e);
+    const errName = e?.name;
+    if (errName === "AbortError" || msg.includes("aborted")) {
+      logger?.log?.(
+        `[server-binding] ${uid}: timed out after ${timeoutMs}ms (cloud unreachable)`
+      );
+    } else if (msg.includes("ENOTFOUND") || msg.includes("EAI_AGAIN")) {
+      logger?.log?.(
+        `[server-binding] ${uid}: DNS failed (${msg}) \u2014 apis.reolink.com may be blocked at resolver`
+      );
+    } else if (msg.includes("ECONNREFUSED") || msg.includes("EHOSTUNREACH") || msg.includes("ENETUNREACH")) {
+      logger?.log?.(
+        `[server-binding] ${uid}: network unreachable (${msg}) \u2014 cloud port blocked`
+      );
+    } else {
+      logger?.log?.(`[server-binding] ${uid}: fetch failed \u2014 ${msg}`);
+    }
     cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
     return void 0;
   } finally {
@@ -11801,12 +11870,19 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
     const tid = (Math.floor(Math.random() * 2147483647) | 0) >>> 0;
     const xml = buildC2mQ({ uid });
     const pkt = encodeDiscoveryPacket(tid, xml);
+    const counters = { sentBytes: 0, rxBytes: 0 };
     return await new Promise((resolve, reject) => {
       const deadline = setTimeout(() => {
         cleanup();
-        reject(new Error(`P2P UID lookup timeout (${dest.host}:${dest.port})`));
+        const err = new Error(
+          `P2P UID lookup timeout (${dest.host}:${dest.port}) \u2014 sent=${counters.sentBytes}B rx=${counters.rxBytes}B`
+        );
+        err.sentBytes = counters.sentBytes;
+        err.rxBytes = counters.rxBytes;
+        reject(err);
       }, timeoutMs);
       const onMsg = (msg) => {
+        counters.rxBytes += msg.length;
         try {
           const p = decodeBcUdpPacket(msg);
           if (p.kind !== "discovery") return;
@@ -11814,13 +11890,19 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
           const qr = parseM2cQr(p.xml);
           if (!qr?.reg || !qr?.relay) return;
           cleanup();
-          resolve({ reg: qr.reg, relay: qr.relay });
+          resolve({
+            reg: qr.reg,
+            relay: qr.relay,
+            sentBytes: counters.sentBytes,
+            rxBytes: counters.rxBytes
+          });
         } catch {
         }
       };
       const send = () => {
         try {
           sock.send(pkt, dest.port, dest.host);
+          counters.sentBytes += pkt.length;
         } catch {
         }
       };
@@ -12811,35 +12893,88 @@ function decodeHeader(buf) {
   return { header, headerLen, messageKey };
 }
 var BaichuanFrameParser = class {
+  /** Retained-but-unconsumed contiguous bytes from previous push() calls. */
   buffer = Buffer.alloc(0);
+  /** Chunks received since the last materialization, not yet concatenated. */
+  pending = [];
+  /** Total bytes held in `pending` (kept in sync to avoid re-summing). */
+  pendingLen = 0;
+  /**
+   * Total contiguous bytes (`buffer` + `pending`) required before the next
+   * parse attempt can make progress. While buffered bytes stay below this,
+   * incoming chunks are merely stashed in `pending` with no copy. This is
+   * the mechanism that turns the worst case (a large frame fragmented over
+   * many small TCP chunks) from O(n²) into O(n): we concatenate once, when
+   * enough bytes have arrived, instead of on every chunk.
+   *
+   * Starts at 4 — the minimum needed to inspect the magic header.
+   */
+  needed = 4;
+  /**
+   * Collapse `this.buffer` + all `pending` chunks into a single contiguous
+   * buffer. The retained leftover is copied at most once per materialize(),
+   * and materialize() only runs when `needed` bytes are available — so a
+   * fragmented frame is assembled with a single concat, not one per chunk.
+   */
+  materialize() {
+    if (this.pendingLen === 0) return;
+    if (this.buffer.length === 0 && this.pending.length === 1) {
+      this.buffer = this.pending[0];
+    } else {
+      const parts = this.buffer.length === 0 ? this.pending : [this.buffer, ...this.pending];
+      this.buffer = Buffer.concat(parts);
+    }
+    this.pending = [];
+    this.pendingLen = 0;
+  }
+  /** Total buffered bytes, whether materialized or still pending. */
+  get available() {
+    return this.buffer.length + this.pendingLen;
+  }
   push(chunk) {
     if (chunk.length === 0) return [];
-    const c = chunk;
-    this.buffer = this.buffer.length === 0 ? c : Buffer.concat([this.buffer, c]);
+    this.pending.push(chunk);
+    this.pendingLen += chunk.length;
+    if (this.available < this.needed) return [];
+    this.materialize();
     const out = [];
     while (true) {
-      if (this.buffer.length < 4) break;
+      if (this.buffer.length < 4) {
+        this.needed = 4;
+        break;
+      }
       if (!this.buffer.subarray(0, 4).equals(BC_MAGIC) && !this.buffer.subarray(0, 4).equals(BC_MAGIC_REV)) {
         const idx = this.buffer.indexOf(BC_MAGIC);
         const idxRev = this.buffer.indexOf(BC_MAGIC_REV);
         const next = idx === -1 ? idxRev : idxRev === -1 ? idx : Math.min(idx, idxRev);
         if (next === -1) {
           this.buffer = this.buffer.subarray(Math.max(0, this.buffer.length - 3));
+          this.needed = 4;
           break;
         }
         this.buffer = this.buffer.subarray(next);
-        if (this.buffer.length < 20) break;
+        if (this.buffer.length < 20) {
+          this.needed = 20;
+          break;
+        }
+      }
+      if (this.buffer.length < 20) {
+        this.needed = 20;
+        break;
       }
-      if (this.buffer.length < 20) break;
       let headerInfo;
       try {
         headerInfo = decodeHeader(this.buffer);
       } catch {
+        this.needed = 24;
         break;
       }
       const { header, headerLen, messageKey } = headerInfo;
       const frameLen = headerLen + header.bodyLen;
-      if (this.buffer.length < frameLen) break;
+      if (this.buffer.length < frameLen) {
+        this.needed = frameLen;
+        break;
+      }
       const raw = this.buffer.subarray(0, frameLen);
       const body = raw.subarray(headerLen);
       let extLen = 0;
@@ -12851,6 +12986,7 @@ var BaichuanFrameParser = class {
       const payload = body.subarray(extLen);
       out.push({ header, body, extension, payload, messageKey, raw });
       this.buffer = this.buffer.subarray(frameLen);
+      this.needed = 4;
     }
     return out;
   }