@apocaliss92/nodelink-js 0.1.18 → 0.1.20

package/dist/{DiagnosticsTools-6WEMO4L4.js → DiagnosticsTools-NUMCYEKQ.js}

@@ -9,7 +9,7 @@ import {
   runMultifocalDiagnosticsConsecutively,
   sampleStreams,
   testChannelStreams
-} from "./chunk-ZE7D7LI4.js";
+} from "./chunk-YPU7RAEY.js";
 export {
   collectCgiDiagnostics,
   collectMultifocalDiagnostics,
@@ -22,4 +22,4 @@ export {
   sampleStreams,
   testChannelStreams
 };
-//# sourceMappingURL=DiagnosticsTools-6WEMO4L4.js.map
+//# sourceMappingURL=DiagnosticsTools-NUMCYEKQ.js.map

package/dist/{chunk-ULSFEQSE.js → chunk-EHWVA3SG.js}

@@ -136,7 +136,7 @@ import {
   talkTraceLog,
   traceLog,
   xmlEscape
-} from "./chunk-ZE7D7LI4.js";
+} from "./chunk-YPU7RAEY.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -8753,7 +8753,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");
@@ -8777,7 +8778,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;
@@ -9454,14 +9456,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 = [
@@ -9545,6 +9549,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;
@@ -9575,6 +9587,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();
@@ -9959,14 +9980,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
@@ -9986,9 +10009,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`;
+      }
+      if (this._isMultiFocal) {
+        const isSocketA = channel === 0 && profile === "main" || channel === 1 && profile === "sub";
+        return isSocketA ? "streaming:a" : "general";
       }
-      return `streaming:ch${channel}`;
+      return this._isNvr ? `streaming:ch${channel}` : `streaming:ch${channel}`;
     }
     return "general";
   }
@@ -10313,6 +10343,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?.();
@@ -10861,11 +10899,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.
@@ -10879,6 +10921,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     }
     if (this.simpleEventListeners.size === 0) {
       this.stopSimpleEventResubscribeTimer();
+      this.stopSimpleEventWatchdog();
       this.stopUdpSleepInference();
       await this.ensureSimpleEventUnsubscribed();
     } else {
@@ -10902,6 +10945,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)
@@ -11040,6 +11174,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.
    *
@@ -11090,6 +11235,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     }
     this.stopStatePolling();
     this.stopUdpSleepInference();
+    this.stopSimpleEventWatchdog();
+    this.stopSimpleEventResubscribeTimer();
     await this.cleanup();
     await this.stopAllActiveStreams();
     await this.cleanupSocketPool();
@@ -16541,7 +16688,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",
@@ -16946,7 +17093,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-6WEMO4L4.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-NUMCYEKQ.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -16962,7 +17109,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-6WEMO4L4.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-NUMCYEKQ.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -20065,4 +20212,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-ULSFEQSE.js.map
+//# sourceMappingURL=chunk-EHWVA3SG.js.map