@apocaliss92/nodelink-js 0.1.17 → 0.1.20

package/dist/cli/rtsp-server.cjs

@@ -1196,6 +1196,22 @@ function detectVideoCodecFromNal(data) {
   if (nalStart < 0 || nalStart >= data.length) return null;
   const nalByte = data[nalStart];
   if (nalByte === void 0) return null;
+  const forbiddenBit264 = nalByte >> 7 & 1;
+  const h264Type = nalByte & 31;
+  if (forbiddenBit264 === 0 && h264Type > 0 && h264Type <= 12) {
+    if (h264Type === 7 || h264Type === 8) {
+      return "H264";
+    }
+    if (h264Type === 5) {
+      return "H264";
+    }
+    if (h264Type === 1) {
+      const nalRefIdc = nalByte >> 5 & 3;
+      if (nalRefIdc >= 1) {
+        return "H264";
+      }
+    }
+  }
   if (nalStart + 1 < data.length) {
     const nalByte2 = data[nalStart + 1];
     if (nalByte2 !== void 0) {
@@ -1209,22 +1225,12 @@ function detectVideoCodecFromNal(data) {
         if (hevcType === 19 || hevcType === 20 || hevcType === 21) {
           return "H265";
         }
-        if (hevcType <= 9) {
+        if (hevcType <= 1 && nalByte <= 3) {
           return "H265";
         }
       }
     }
   }
-  const forbiddenBit264 = nalByte >> 7 & 1;
-  const h264Type = nalByte & 31;
-  if (forbiddenBit264 === 0 && h264Type > 0 && h264Type <= 12) {
-    if (h264Type === 7 || h264Type === 8) {
-      return "H264";
-    }
-    if (h264Type === 5 || h264Type === 1) {
-      return "H264";
-    }
-  }
   return null;
 }
 var ANNEXB_START_CODE_4B, BcMediaAnnexBDecoder;
@@ -15652,7 +15658,8 @@ var logDebugStreamBlock = (params) => {
   const bitRateText = getXmlText(raw, "bitRate") ?? getXmlText(raw, "BitRate");
   const videoEncTypeText = getXmlText(raw, "videoEncType") ?? getXmlText(raw, "VideoEncType");
   const audioText = getXmlText(raw, "audio") ?? getXmlText(raw, "Audio");
-  const enableText = getXmlText(raw, "enable") ?? getXmlText(raw, "Enable");
+  const enableCheckRaw = raw.replace(/<smartH265[\s\S]*?<\/smartH265>/g, "");
+  const enableText = getXmlText(enableCheckRaw, "enable") ?? getXmlText(enableCheckRaw, "Enable");
   const width = Number(widthText ?? "0");
   const height = Number(heightText ?? "0");
   const frameRate = Number(frameText ?? "0");
@@ -15676,7 +15683,8 @@ var buildStream = (params) => {
   const frameRate = Number(getXmlText(streamXml, "frame") ?? "0");
   const bitRate = Number(getXmlText(streamXml, "bitRate") ?? "0");
   const audio = Number(getXmlText(streamXml, "audio") ?? "0");
-  const enabled = getXmlText(streamXml, "enable");
+  const enableXml = streamXml.replace(/<smartH265[\s\S]*?<\/smartH265>/g, "");
+  const enabled = getXmlText(enableXml, "enable");
   const isEnabled = isEnabledFromText(enabled);
   if (!isEnabled || !isPlausibleStream({ width, height, frameRate, bitRate }))
     return void 0;
@@ -16365,14 +16373,16 @@ var DUAL_LENS_SINGLE_MOTION_MODELS = /* @__PURE__ */ new Set([
   "Reolink TrackMix",
   "Reolink TrackMix PoE",
   "Reolink TrackMix WiFi",
-  "RLC-81MA"
+  "RLC-81MA",
+  "TrackFlex Floodlight WiFi"
 ]);
 var DUAL_LENS_MODELS = /* @__PURE__ */ new Set([
   ...DUAL_LENS_DUAL_MOTION_MODELS,
   ...DUAL_LENS_SINGLE_MOTION_MODELS
 ]);
 var isDualLenseModel = (model) => {
-  return DUAL_LENS_MODELS.has(model) || model.toLowerCase().includes("trackmix");
+  const lower = model.toLowerCase();
+  return Array.from(DUAL_LENS_MODELS).some((m) => m.toLowerCase() === lower) || lower.includes("trackmix") || lower.includes("trackflex");
 };
 var NVR_HUB_EXACT_TYPES = ["NVR", "WIFI_NVR", "HOMEHUB"];
 var NVR_HUB_MODEL_PATTERNS = [
@@ -16456,6 +16466,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Set via setIsNvr() from the plugin or auto-detected via isNvrDevice().
    */
   _isNvr;
+  /**
+   * Cached multi-focal detection result.
+   * - true = dual-lens camera (e.g., TrackMix, TrackFlex) with multiple channels on a single device
+   * - false = single-lens camera
+   * Multi-focal cameras reject concurrent streaming TCP connections (response_code 430),
+   * so all channels must multiplex on the same streaming socket.
+   */
+  _isMultiFocal;
   /** Maximum dedicated sessions allowed before triggering a reboot (default: 7). */
   maxDedicatedSessionsBeforeReboot;
   sessionGuardRebootInFlight;
@@ -16486,6 +16504,15 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   simpleEventResubscribeTimer;
   simpleEventResubscribeInFlight;
   simpleEventResubscribeIntervalMs = 5 * 6e4;
+  // Event watchdog: auto-recovery when events stop flowing or subscription fails
+  simpleEventWatchdogTimer;
+  simpleEventLastReceivedAt = 0;
+  simpleEventWatchdogRecoveryAttempts = 0;
+  simpleEventWatchdogLastRecoveryAt = 0;
+  simpleEventWatchdogIntervalMs = 1e4;
+  // check every 10s
+  simpleEventWatchdogSilenceThresholdMs = 5 * 6e4;
+  // 5 min without events
   statePollingInterval;
   udpSleepInferenceInterval;
   udpLastInferredSleepStateByChannel = /* @__PURE__ */ new Map();
@@ -16870,14 +16897,16 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Determine the socket tag for a given sessionKey.
    * This implements the tag-based allocation strategy:
    *
-   * - "general" - commands, events
-   * - "streaming:ch{N}" - main + sub for channel N (closed when no streams)
-   * - "streaming:ch{N}:ext" - ext for channel N (closed when no streams)
+   * - "general" - commands, events, ext on ch0
+   * - "streaming:ch{N}" - main + sub for channel N (NVR/standalone single-lens)
+   * - "streaming:ch{N}:ext" - ext for channel N (NVR/standalone, N>0)
+   * - "streaming:a" - ch0 main + ch1 sub (multi-focal dedicated socket)
+   * - "general" also carries ch1 main + ch0 sub for multi-focal (merged with commands/events)
    * - "replay:deviceId:ch{N}" - dedicated per device+channel for replay
    *
-   * Always uses per-channel tagging for streams (works for both standalone and NVR).
-   * Replay uses per-device+channel sockets to allow multiple users to watch
-   * different clips simultaneously without interfering with each other.
+   * Multi-focal cameras (TrackMix, TrackFlex, Duo) reject two main or two sub
+   * streams on the same TCP connection (response_code 430). Cross-channel pairing
+   * ensures each socket always has a valid M+S combination using only 2 TCP connections.
    *
    * @param sessionKey - The session key (e.g., "live:device:ch0:main", "replay:device:ch1:file")
    * @returns The socket pool tag to use
@@ -16897,9 +16926,16 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         if (channel === 0) {
           return "general";
         }
-        return `streaming:ch${channel}:ext`;
+        if (this._isMultiFocal) {
+          return "general";
+        }
+        return this._isNvr ? `streaming:ch${channel}:ext` : `streaming:ch${channel}:ext`;
       }
-      return `streaming:ch${channel}`;
+      if (this._isMultiFocal) {
+        const isSocketA = channel === 0 && profile === "main" || channel === 1 && profile === "sub";
+        return isSocketA ? "streaming:a" : "general";
+      }
+      return this._isNvr ? `streaming:ch${channel}` : `streaming:ch${channel}`;
     }
     return "general";
   }
@@ -17224,6 +17260,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   async cleanupDedicatedClients() {
   }
   dispatchSimpleEvent(evt) {
+    this.simpleEventLastReceivedAt = Date.now();
+    if (this.simpleEventWatchdogRecoveryAttempts > 0) {
+      (this.logger.info ?? this.logger.log).call(
+        this.logger,
+        `[ReolinkBaichuanApi] event watchdog: events flowing again after ${this.simpleEventWatchdogRecoveryAttempts} recovery attempt(s)`
+      );
+      this.simpleEventWatchdogRecoveryAttempts = 0;
+    }
     const debugCfg = this.client.getDebugConfig?.();
     if (debugCfg) {
       const sid = this.client.getSocketSessionId?.();
@@ -17772,11 +17816,15 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   /**
    * Subscribe to minimal high-level events.
    * The API manages Baichuan subscribe/unsubscribe automatically.
+   * Includes built-in watchdog: if no events arrive for 5 minutes while
+   * the connection is alive, the subscription is automatically renewed.
    */
   async onSimpleEvent(callback) {
     this.simpleEventListeners.add(callback);
     await this.ensureSimpleEventSubscribed();
+    this.simpleEventLastReceivedAt = Date.now();
     this.startSimpleEventResubscribeTimer();
+    this.startSimpleEventWatchdog();
   }
   /**
    * Remove one callback, or all callbacks if omitted.
@@ -17790,6 +17838,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     }
     if (this.simpleEventListeners.size === 0) {
       this.stopSimpleEventResubscribeTimer();
+      this.stopSimpleEventWatchdog();
       this.stopUdpSleepInference();
       await this.ensureSimpleEventUnsubscribed();
     } else {
@@ -17813,6 +17862,97 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     clearInterval(this.simpleEventResubscribeTimer);
     this.simpleEventResubscribeTimer = void 0;
   }
+  /**
+   * Event watchdog: monitors whether events are flowing and auto-recovers if they stop.
+   *
+   * Handles two failure modes:
+   * 1. Subscription flag is true but no events arrive for 5+ minutes (device dropped subscription silently)
+   * 2. Subscription flag is false because initial/retry subscribe failed, but connection is now alive
+   *
+   * Uses exponential backoff (30s → 60s → 120s → 240s → max 5min) to avoid hammering the device.
+   */
+  startSimpleEventWatchdog() {
+    if (this.simpleEventWatchdogTimer) return;
+    if (this.simpleEventListeners.size === 0) return;
+    this.simpleEventWatchdogTimer = setInterval(() => {
+      void this.simpleEventWatchdogTick();
+    }, this.simpleEventWatchdogIntervalMs);
+  }
+  stopSimpleEventWatchdog() {
+    if (!this.simpleEventWatchdogTimer) return;
+    clearInterval(this.simpleEventWatchdogTimer);
+    this.simpleEventWatchdogTimer = void 0;
+    this.simpleEventWatchdogRecoveryAttempts = 0;
+    this.simpleEventWatchdogLastRecoveryAt = 0;
+    this.simpleEventLastReceivedAt = 0;
+  }
+  async simpleEventWatchdogTick() {
+    if (this.simpleEventListeners.size === 0) return;
+    if (!this.client.isSocketConnected?.() || !this.client.loggedIn) return;
+    const now = Date.now();
+    if (this.simpleEventSubscribed && this.simpleEventLastReceivedAt > 0) {
+      const silence = now - this.simpleEventLastReceivedAt;
+      if (silence < this.simpleEventWatchdogSilenceThresholdMs) return;
+      (this.logger.warn ?? this.logger.log).call(
+        this.logger,
+        `[ReolinkBaichuanApi] event watchdog: no events for ${Math.round(silence / 6e4)} min, forcing resubscribe`,
+        { host: this.host, silenceMs: silence }
+      );
+      try {
+        this.simpleEventSubscribed = false;
+        this.client.subscribed = false;
+        await this.ensureSimpleEventSubscribed();
+        this.simpleEventLastReceivedAt = Date.now();
+        this.simpleEventWatchdogRecoveryAttempts = 0;
+        (this.logger.info ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: resubscribed successfully after silence`
+        );
+      } catch (e) {
+        (this.logger.debug ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: resubscribe after silence failed`,
+          formatErrorForLog(e)
+        );
+      }
+      return;
+    }
+    if (!this.simpleEventSubscribed) {
+      const backoffMs = Math.min(
+        3e4 * Math.pow(2, this.simpleEventWatchdogRecoveryAttempts),
+        this.simpleEventWatchdogSilenceThresholdMs
+      );
+      if (now - this.simpleEventWatchdogLastRecoveryAt < backoffMs) return;
+      this.simpleEventWatchdogRecoveryAttempts++;
+      this.simpleEventWatchdogLastRecoveryAt = now;
+      const nextBackoff = Math.min(
+        3e4 * Math.pow(2, this.simpleEventWatchdogRecoveryAttempts),
+        this.simpleEventWatchdogSilenceThresholdMs
+      );
+      (this.logger.info ?? this.logger.log).call(
+        this.logger,
+        `[ReolinkBaichuanApi] event watchdog: subscription inactive, attempting auto-recovery (attempt #${this.simpleEventWatchdogRecoveryAttempts}, next backoff ${Math.round(nextBackoff / 1e3)}s)`,
+        { host: this.host }
+      );
+      try {
+        await this.ensureSimpleEventSubscribed();
+        if (this.simpleEventSubscribed) {
+          this.simpleEventLastReceivedAt = Date.now();
+          (this.logger.info ?? this.logger.log).call(
+            this.logger,
+            `[ReolinkBaichuanApi] event watchdog: auto-recovery successful after ${this.simpleEventWatchdogRecoveryAttempts} attempt(s)`
+          );
+          this.simpleEventWatchdogRecoveryAttempts = 0;
+        }
+      } catch (e) {
+        (this.logger.debug ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: recovery attempt #${this.simpleEventWatchdogRecoveryAttempts} failed`,
+          formatErrorForLog(e)
+        );
+      }
+    }
+  }
   async renewSimpleEventSubscription() {
     if (this.simpleEventListeners.size === 0) return;
     if (this.simpleEventResubscribeInFlight)
@@ -17951,6 +18091,17 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     this._isNvr = isNvr;
     this.logger.debug?.(`[ReolinkBaichuanApi] setIsNvr: ${isNvr}`);
   }
+  /**
+   * Set the multi-focal flag explicitly.
+   * Call this early (before streaming) to ensure correct socket pooling.
+   * Multi-focal cameras (TrackMix, TrackFlex, Duo, etc.) reject concurrent
+   * streaming TCP connections, so all channels must share a single streaming socket.
+   * @param isMultiFocal - true if this is a dual-lens/multi-focal camera
+   */
+  setIsMultiFocal(isMultiFocal) {
+    this._isMultiFocal = isMultiFocal;
+    this.logger.debug?.(`[ReolinkBaichuanApi] setIsMultiFocal: ${isMultiFocal}`);
+  }
   /**
    * Enable or disable idle disconnect dynamically.
    *
@@ -18001,6 +18152,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     }
     this.stopStatePolling();
     this.stopUdpSleepInference();
+    this.stopSimpleEventWatchdog();
+    this.stopSimpleEventResubscribeTimer();
     await this.cleanup();
     await this.stopAllActiveStreams();
     await this.cleanupSocketPool();
@@ -23452,7 +23605,7 @@ ${xml}`
       });
       model = typeof info.type === "string" ? info.type.toLowerCase() : "";
       isMultiFocal = isDualLenseModel(model);
-      isTrackMix = model.includes("trackmix");
+      isTrackMix = model.includes("trackmix") || model.includes("trackflex");
     } catch (e) {
       logDebug(
         "[ReolinkBaichuanApi] buildVideoStreamOptions: getInfo(type) failed",