@apocaliss92/scrypted-reolink-native 0.4.28 → 0.4.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apocaliss92/scrypted-reolink-native",
-  "version": "0.4.28",
+  "version": "0.4.30",
   "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
   "author": "@apocaliss92",
   "license": "Apache",

package/src/baichuan-base.ts

@@ -277,26 +277,39 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
       return await this.ensureClientPromise;
     }
 
-    // Reuse existing client if socket is still connected and logged in
-    // Check this AFTER checking the promise to avoid race conditions
+    // Reuse existing API if possible
     if (this.baichuanApi) {
-      const isConnected = this.baichuanApi.client.isSocketConnected();
-      const isLoggedIn = this.baichuanApi.client.loggedIn;
-
-      // Only reuse if both conditions are true
-      if (isConnected && isLoggedIn) {
+      // Already connected and ready → reuse immediately
+      if (this.baichuanApi.isReady) {
         logger.debug(
           `ensureBaichuanClient: reusing existing client (caller: ${caller})`,
         );
         return this.baichuanApi;
       }
 
-      // If socket is not connected or not logged in, cleanup the stale client
-      // This prevents leaking connections when the socket appears connected but isn't
-      logger.log(
-        `Stale client detected: connected=${isConnected}, loggedIn=${isLoggedIn}, cleaning up (caller: ${caller})`,
-      );
-      await this.cleanupBaichuanApi();
+      // API was explicitly closed → destroy and recreate from scratch
+      if (this.baichuanApi.isClosed) {
+        logger.log(
+          `API is closed, creating new instance (caller: ${caller})`,
+        );
+        await this.cleanupBaichuanApi();
+      } else {
+        // Socket disconnected but API still valid → let the library reconnect
+        // the general socket internally (preserves NVR/multifocal flags,
+        // streaming sockets, and all library-side state)
+        try {
+          logger.log(
+            `General socket lost, reconnecting via ensureConnected (caller: ${caller})`,
+          );
+          await this.baichuanApi.ensureConnected();
+          return this.baichuanApi;
+        } catch (e) {
+          logger.log(
+            `ensureConnected failed: ${e instanceof Error ? e.message : String(e)}, creating new instance`,
+          );
+          await this.cleanupBaichuanApi();
+        }
+      }
     }
 
     logger.log(`ensureBaichuanClient: creating NEW client (caller: ${caller})`);
@@ -543,11 +556,14 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
 
       // Stop event check interval
       this.stopEventCheck();
-
-      // Reset state
+    } finally {
+      // Reset state ALWAYS — even if an earlier step threw.
+      // This prevents the client from being permanently "stuck":
+      // if baichuanApi remains set with a destroyed socket pool,
+      // ensureBaichuanClient() will repeatedly crash on the `client` getter
+      // and never recover.
       this.baichuanApi = undefined;
       this.ensureClientPromise = undefined;
-    } finally {
       this.cleanupInProgress = false;
     }
   }
@@ -558,13 +574,9 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
   private getAllActiveConnections(): ReolinkBaichuanApi[] {
     const connections: ReolinkBaichuanApi[] = [];
 
-    // Add main connection if exists and is valid
-    if (this.baichuanApi) {
-      const isConnected = this.baichuanApi.client.isSocketConnected();
-      const isLoggedIn = this.baichuanApi.client.loggedIn;
-      if (isConnected && isLoggedIn) {
-        connections.push(this.baichuanApi);
-      }
+    // Add main connection if it exists and is ready (safe, never throws)
+    if (this.baichuanApi?.isReady) {
+      connections.push(this.baichuanApi);
     }
 
     return connections;
@@ -715,14 +727,10 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
         return; // Connection changed, stop this interval
       }
 
-      // If event subscription is not active but the connection is alive and
-      // event subscription is desired, attempt to re-subscribe.
-      // This handles the case where subscribeToEvents() failed during
-      // reconnection (e.g. ECONNREFUSED) but the connection was later
-      // re-established by the streaming infrastructure.
+      // If event subscription is not active, skip — the library's
+      // built-in event watchdog handles auto-recovery with exponential
+      // backoff (including after reconnection / camera reboot).
       if (!this.eventSubscriptionActive) {
-        // The library's built-in event watchdog handles auto-recovery
-        // with exponential backoff. No need to retry here.
         return;
       }
 
@@ -849,7 +857,6 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
    */
   async unsubscribeFromEvents(silent: boolean = false): Promise<void> {
     const logger = this.getBaichuanLogger();
-    const callbacks = this.getConnectionCallbacks();
 
     // Only unsubscribe if we have an active subscription
     if (

package/src/camera.ts

@@ -3507,38 +3507,22 @@ export class ReolinkCamera
   }
 
   async resetBaichuanClient(reason?: any): Promise<void> {
-    try {
-      // Close all active streams before resetting the client
-      // This ensures no streams remain active when the client is reset
-      if (this.streamManager) {
-        try {
-          const hasActiveStreams = this.streamManager.hasActiveStreams();
-          if (hasActiveStreams) {
-            const logger = this.getBaichuanLogger();
-            logger.log("Closing all active streams due to client reset");
-            await this.streamManager.closeAllStreams("client reset");
-          }
-        } catch (e) {
-          const logger = this.getBaichuanLogger();
-          logger.error(
-            "Error closing streams during client reset:",
-            e?.message || String(e),
-          );
-        }
-      }
-
-      this.unsubscribedToEvents?.();
-      await this.baichuanApi?.close();
-    } catch (e) {
-      this.getBaichuanLogger().error(
-        "Error closing Baichuan client during reset",
-        e?.message || String(e),
-      );
-    } finally {
-      this.baichuanApi = undefined;
-      this.connectionTime = undefined;
-      this.ensureClientPromise = undefined;
-    }
+    // Delegate to cleanupBaichuanApi() which properly:
+    //  - unsubscribes from events (offSimpleEvent)
+    //  - calls onBeforeCleanup (closes streams, etc.)
+    //  - removes close/error listeners
+    //  - stops connection maintenance timers (ping, auto-renewal)
+    //  - stops event check interval
+    //  - uses cleanupInProgress guard to prevent races
+    // Previously this method called api.close() directly, which left
+    // listeners attached, timers running, and could race with the
+    // close handler's own cleanupBaichuanApi() call.
+    await this.cleanupBaichuanApi();
+
+    // Ensure state is fully reset even if cleanup was a no-op
+    // (e.g. baichuanApi was already undefined)
+    this.connectionTime = undefined;
+    this.ensureClientPromise = undefined;
 
     if (reason) {
       const message = reason?.message || reason?.toString?.() || reason;

package/src/intercom.ts

@@ -205,9 +205,32 @@ export class ReolinkBaichuanIntercom {
 
       this.ffmpeg = ffmpeg;
 
+      // Startup timeout: if ffmpeg has not produced any PCM output within
+      // this window it is likely stuck on RTSP connection negotiation.
+      // Kill it early with a clear error rather than hanging silently.
+      const STARTUP_TIMEOUT_MS = 10_000;
+      let receivedFirstPcm = false;
+      const startupTimer = setTimeout(() => {
+        if (!receivedFirstPcm && this.ffmpeg === ffmpeg) {
+          logger.warn(
+            `Intercom ffmpeg startup timeout (${STARTUP_TIMEOUT_MS}ms): no PCM data received, killing process`,
+          );
+          try {
+            ffmpeg.kill("SIGKILL");
+          } catch {
+            // ignore
+          }
+        }
+      }, STARTUP_TIMEOUT_MS);
+
       ffmpeg.stdout.on("data", (chunk: Buffer) => {
         if (this.session !== session) return;
         if (!chunk?.length) return;
+        if (!receivedFirstPcm) {
+          receivedFirstPcm = true;
+          clearTimeout(startupTimer);
+          logger.log("Intercom ffmpeg: first PCM data received");
+        }
         this.enqueuePcm(session, chunk, bytesNeeded, blockSize);
       });
 
@@ -220,6 +243,7 @@ export class ReolinkBaichuanIntercom {
       });
 
       ffmpeg.on("exit", (code, signal) => {
+        clearTimeout(startupTimer);
         logger.warn(`Intercom ffmpeg exited code=${code} signal=${signal}`);
         this.stop().catch(() => {});
       });
@@ -380,9 +404,20 @@ export class ReolinkBaichuanIntercom {
 
     // FFmpegInput may already contain one or more "-i" entries.
     // For intercom decode, we only need a single input and only the first audio stream.
+    //
+    // IMPORTANT: We must also strip `-rtsp_transport tcp` (and similar transport
+    // overrides) inherited from the upstream FFmpegInput.  The RTSP URL points at a
+    // local relay server (e.g. from the WebRTC plugin) that typically only supports
+    // RTP/UDP.  Forcing TCP causes ffmpeg to hang on SETUP negotiation (the relay
+    // replies 461 Unsupported Transport) and eventually get SIGKILLed with no audio
+    // ever reaching the intercom pipeline.
     const sanitizedArgs: string[] = [];
     let chosenInput: string | undefined;
 
+    // Set of pre-input flags that take a value argument and should be stripped
+    // because they conflict with the local RTSP relay's transport capabilities.
+    const stripWithValue = new Set(["-rtsp_transport"]);
+
     for (let i = 0; i < inputArgs.length; i++) {
       const arg = inputArgs[i];
       if (arg === "-i") {
@@ -397,6 +432,12 @@ export class ReolinkBaichuanIntercom {
         }
       }
 
+      // Strip transport-related flags that break the local RTSP relay.
+      if (stripWithValue.has(arg)) {
+        i++; // skip the value argument as well
+        continue;
+      }
+
       sanitizedArgs.push(arg);
     }