@apocaliss92/nodelink-js 0.6.7 → 0.6.8-beta.0

package/dist/cli/rtsp-server.js

@@ -3,11 +3,11 @@ import {
   BaichuanRtspServer,
   ReolinkBaichuanApi,
   autoDetectDeviceType
-} from "../chunk-T22QCNBR.js";
-import "../chunk-IQVVVSXO.js";
+} from "../chunk-OJ4YR45R.js";
+import "../chunk-27ZKJZFH.js";
 import {
   __require
-} from "../chunk-MZUSWKF3.js";
+} from "../chunk-4LZABN6I.js";
 
 // src/cli/rtsp-server.ts
 function parseArgs() {

package/dist/index.cjs

@@ -2311,6 +2311,14 @@ var init_BaichuanVideoStream = __esm({
       logger;
       active = false;
       videoFrameHandler;
+      // Fired when the underlying BaichuanClient socket closes/errors (e.g. the
+      // keepalive watchdog tears down a half-open socket after a camera reboot).
+      // Without this, the stream keeps believing it is active and only the idle
+      // watchdog would (eventually, and uselessly) try to restart on a dead
+      // client. Surfacing the socket death as a stream "close" lets the consumer
+      // (createNativeStream → fanout onEnd → BaichuanRtspServer) rebuild the
+      // stream on a fresh dedicated session.
+      clientCloseHandler;
       expectedStreamTypes;
       activeMsgNum;
       cmdId;
@@ -3191,6 +3199,19 @@ var init_BaichuanVideoStream = __esm({
           }
         };
         this.client.on("push", this.videoFrameHandler);
+        this.clientCloseHandler = () => {
+          if (!this.active) return;
+          this.logger?.warn?.(
+            `[BaichuanVideoStream] underlying socket closed (channel=${this.channel} profile=${this.profile}) \u2014 ending stream for rebuild`
+          );
+          this.active = false;
+          this.stopWatchdog();
+          if (this.videoFrameHandler)
+            this.client.off("push", this.videoFrameHandler);
+          this.videoFrameHandler = void 0;
+          this.emit("close");
+        };
+        this.client.on("close", this.clientCloseHandler);
         this.active = true;
         this.startWatchdog();
         if (this.api && typeof this.api._registerVideoStreamForDetection === "function") {
@@ -3261,6 +3282,10 @@ var init_BaichuanVideoStream = __esm({
               if (this.videoFrameHandler)
                 this.client.off("push", this.videoFrameHandler);
               this.videoFrameHandler = void 0;
+              if (this.clientCloseHandler) {
+                this.client.off("close", this.clientCloseHandler);
+                this.clientCloseHandler = void 0;
+              }
               throw err;
             }
             this.emitSafeError(err);
@@ -3281,6 +3306,10 @@ var init_BaichuanVideoStream = __esm({
           this.client.removeListener("push", this.videoFrameHandler);
         }
         this.videoFrameHandler = void 0;
+        if (this.clientCloseHandler) {
+          this.client.removeListener("close", this.clientCloseHandler);
+          this.clientCloseHandler = void 0;
+        }
         this.bcMediaCodec.clear();
         this.activeMsgNum = void 0;
         if (this.api) {
@@ -10916,6 +10945,16 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
   // Public to allow ReolinkBaichuanApi to check subscription status
   keepAliveTimer;
   keepAlivePingInFlight = false;
+  // Consecutive TCP keepalive (PING) failures with no response. A half-open
+  // socket after a camera reboot is NOT reported as `destroyed`, so
+  // `isSocketConnected()` stays stale-true and recovery never triggers. We
+  // treat repeated unanswered pings as a hard liveness failure and tear the
+  // socket down so the 'close' handler fires (resetting loggedIn/subscribed
+  // and emitting "close"), which lets ensureConnected() rebuild it.
+  consecutiveKeepalivePingFailures = 0;
+  // Number of unanswered keepalive pings tolerated before the TCP socket is
+  // declared dead. 2 misses ≈ up to ~2 keepalive intervals of silence.
+  static KEEPALIVE_MAX_PING_FAILURES = 2;
   // Battery/BCUDP cameras may actively terminate sessions (D2C_DISC) when overwhelmed
   // or sleeping. Without a cooldown, callers can end up in tight reconnect loops.
   udpReconnectCooldownUntilMs = 0;
@@ -11544,8 +11583,21 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
         // Keepalive has empty body
         internal: true
       });
+      this.consecutiveKeepalivePingFailures = 0;
     } catch (e) {
-      this.logDebug("keepalive_ping_failed", e);
+      this.consecutiveKeepalivePingFailures++;
+      this.logDebug("keepalive_ping_failed", {
+        error: e,
+        consecutiveFailures: this.consecutiveKeepalivePingFailures
+      });
+      if (this.transport === "tcp" && this.consecutiveKeepalivePingFailures >= _BaichuanClient.KEEPALIVE_MAX_PING_FAILURES && this.tcpSocket && !this.tcpSocket.destroyed) {
+        this.logFixed(
+          "keepalive_dead",
+          `transport=tcp host=${this.opts.host} consecutiveFailures=${this.consecutiveKeepalivePingFailures} \u2014 destroying half-open socket`
+        );
+        this.consecutiveKeepalivePingFailures = 0;
+        this.tcpSocket.destroy();
+      }
     }
   }
   async connect() {
@@ -11638,6 +11690,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
     this.tcpSocket = sock;
     this.transport = "tcp";
     this.socketClosed = false;
+    this.consecutiveKeepalivePingFailures = 0;
     this.socketSessionId = this.newSocketSessionId("tcp");
     try {
       sock.setKeepAlive(true, 3e4);
@@ -15142,6 +15195,20 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events5.E
   // from the last IDR in the prebuffer immediately.
   PREBUFFER_MAX_MS = 3e3;
   prebuffer = [];
+  /**
+   * Hard cap on the userspace TCP send buffer for a single RTSP client. A
+   * healthy consumer drains near-instantly; if this much data backs up the
+   * client is dead or far too slow to keep up with the live stream.
+   */
+  static MAX_CLIENT_BUFFERED_BYTES = 8 * 1024 * 1024;
+  /**
+   * Pure backpressure decision: should the client socket be disconnected
+   * because its send buffer has grown past the hard cap? Extracted so the
+   * decision can be unit-tested without a live socket.
+   */
+  static shouldDisconnectForBackpressure(bufferedBytes) {
+    return bufferedBytes > _BaichuanRtspServer.MAX_CLIENT_BUFFERED_BYTES;
+  }
   static isAdtsAacFrame(b) {
     return b.length >= 2 && b[0] === 255 && (b[1] & 240) === 240;
   }
@@ -16118,14 +16185,36 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events5.E
     const rtspDebugLog = (message) => this.rtspDebugLog(message);
     const sendInterleaved = (channel, msg) => {
       if (!rtspSocket || rtspSocket.destroyed || !rtspSocket.writable)
-        return false;
+        return true;
+      if (_BaichuanRtspServer.shouldDisconnectForBackpressure(
+        rtspSocket.writableLength
+      )) {
+        this.logger.warn(
+          `[rebroadcast] backpressure: ${Math.round(rtspSocket.writableLength / 1024)}KB buffered for client=${clientId} \u2014 disconnecting`
+        );
+        rtspSocket.destroy();
+        return true;
+      }
       try {
         return rtspSocket.write(frameRtpOverTcp(channel, msg));
       } catch (error) {
         if (error && typeof error === "object" && "code" in error && error.code === "EPIPE")
-          return false;
+          return true;
       }
-      return false;
+      return true;
+    };
+    const awaitClientDrain = async () => {
+      if (!rtspSocket || rtspSocket.destroyed) return;
+      if (!rtspSocket.writableNeedDrain) return;
+      await new Promise((resolve) => {
+        const done = () => {
+          rtspSocket.removeListener("drain", done);
+          rtspSocket.removeListener("close", done);
+          resolve();
+        };
+        rtspSocket.once("drain", done);
+        rtspSocket.once("close", done);
+      });
     };
     const getVideoChannel = () => resources?.track0RtpChannel ?? 0;
     const getAudioChannel = () => resources?.track1RtpChannel ?? 2;
@@ -16704,6 +16793,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events5.E
               resources.framesSent = (resources.framesSent ?? 0) + 1;
             }
             sendVideoAccessUnit(videoType, normalizedVideoData, true);
+            await awaitClientDrain();
           } else {
             try {
               if (stdin && !stdin.destroyed && !stdin.writableEnded && !stdin.writableFinished) {
@@ -23189,9 +23279,45 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const generalEntry = this.socketPool.get("general");
     if (!generalEntry) return;
     if (!generalEntry.client.isSocketConnected?.() || !generalEntry.client.loggedIn) {
-      this.logger.debug?.(
-        `[ReolinkBaichuanApi] event watchdog tick: skipping (connection not alive: connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+      if (!this.eventWatchdogSilenceResubscribeEnabled) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] event watchdog tick: skipping (connection not alive, battery/UDP \u2014 not forcing reconnect: connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+        );
+        return;
+      }
+      const now2 = Date.now();
+      const backoffMs = Math.min(
+        3e4 * Math.pow(2, this.simpleEventWatchdogRecoveryAttempts),
+        this.simpleEventWatchdogSilenceThresholdMs
       );
+      if (now2 - this.simpleEventWatchdogLastRecoveryAt < backoffMs) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] event watchdog tick: connection down, reconnect backoff active (connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+        );
+        return;
+      }
+      this.simpleEventWatchdogRecoveryAttempts++;
+      this.simpleEventWatchdogLastRecoveryAt = now2;
+      (this.logger.info ?? this.logger.log).call(
+        this.logger,
+        `[ReolinkBaichuanApi] event watchdog: control socket down, forcing full reconnect (attempt #${this.simpleEventWatchdogRecoveryAttempts})`,
+        { host: this.host }
+      );
+      try {
+        await this.ensureConnected();
+        this.simpleEventLastReceivedAt = Date.now();
+        this.simpleEventWatchdogRecoveryAttempts = 0;
+        (this.logger.info ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: full reconnect successful`
+        );
+      } catch (e) {
+        (this.logger.debug ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: full reconnect attempt #${this.simpleEventWatchdogRecoveryAttempts} failed`,
+          formatErrorForLog(e)
+        );
+      }
       return;
     }
     const now = Date.now();