@apocaliss92/nodelink-js 0.4.24 → 0.4.28

package/README.md

@@ -39,13 +39,15 @@ await api.onSimpleEvent((event) => {
 
 ## Email Push for Battery Cameras
 
+> 🧪 **Experimental** — the feature is officially enabled but still under active testing. The default flow uses the manager's built-in SMTP server; expect rough edges and please report any issue you hit.
+
 Battery cameras (Argus, Go, …) can't reliably keep a TCP/ONVIF push subscription alive while sleeping. The manager app embeds an SMTP server so the camera can deliver motion alerts via email — the most resilient path for sleep-heavy devices.
 
 **Flow**:
 
-1. Enable the manager's built-in SMTP server (**Settings → Email Push**, default port `2525`).
+1. Enable the manager's built-in SMTP server (**Settings → Email Push**, default port `2525`). All settings (host, port, domain, auth) remain manually editable.
 2. Each camera gets a unique recipient `cam-<id>@<domain>` (`emailPush.getCameraAddress`).
-3. From the camera's **Email Push** tab in the manager UI, click **Auto-configure** — the manager pushes the right SMTP server, recipients and 24/7 schedule to the camera via Baichuan (`baichuan.setupEmailPushToManager`).
+3. From the camera's **Email Push** tab in the manager UI (Camera Settings modal), click **Auto-configure** — the manager pushes the right SMTP server, recipients and 24/7 schedule to the camera via Baichuan (`baichuan.setupEmailPushToManager`). You can also fill the fields by hand in the Reolink app: server = your manager `domain`, sender = `authUsername`, password = `authPassword`, port = `2525`, TLS off, receiver = `cam-<id>@<domain>`.
 4. On motion, the camera sends an email. The manager parses it, classifies the trigger (people/vehicle/motion), saves the snapshot under `${DATA_PATH}/email-push/<cameraId>/`, and emits a synthetic motion event into the same bus used by native Baichuan push — so MQTT, Home Assistant, Frigate, etc. see it transparently.
 
 See [documentation/baichuan-api/email.md](./documentation/baichuan-api/email.md) for the full API and [documentation/baichuan-api/time.md](./documentation/baichuan-api/time.md) for the related NTP / DST / system clock setters.

package/dist/{chunk-JYHK2ZSH.js → chunk-NQ7D5TLR.js}

@@ -5317,6 +5317,21 @@ async function* createNativeStream(api, channel, profile, options) {
   let audioSampleRate = null;
   let streamStarted = false;
   let closed = false;
+  const signal = options?.signal;
+  let sleepResolve = null;
+  let sleepTimer = null;
+  const clearSleepTimer = () => {
+    if (sleepTimer) {
+      clearTimeout(sleepTimer);
+      sleepTimer = null;
+    }
+  };
+  const handleAbort = () => {
+    clearSleepTimer();
+    const r = sleepResolve;
+    sleepResolve = null;
+    r?.();
+  };
   const onError = (_error) => {
     closed = true;
     api.logger?.warn?.(
@@ -5414,7 +5429,13 @@ async function* createNativeStream(api, channel, profile, options) {
       }
     });
     streamStarted = true;
-    const signal = options?.signal;
+    if (signal) {
+      if (signal.aborted) {
+        closed = true;
+      } else {
+        signal.addEventListener("abort", handleAbort);
+      }
+    }
     while (!closed && !signal?.aborted) {
       if (frameQueue.length > 0) {
         const frame = frameQueue.shift();
@@ -5422,31 +5443,30 @@ async function* createNativeStream(api, channel, profile, options) {
       } else {
         await new Promise((resolve) => {
           frameResolve = resolve;
-          const timer = setTimeout(() => {
+          sleepResolve = resolve;
+          sleepTimer = setTimeout(() => {
+            sleepTimer = null;
+            if (sleepResolve === resolve) sleepResolve = null;
             if (frameResolve === resolve) {
               frameResolve = null;
               resolve();
             }
           }, 1e3);
-          if (signal) {
-            const onAbort = () => {
-              clearTimeout(timer);
-              if (frameResolve === resolve) frameResolve = null;
-              resolve();
-            };
-            if (signal.aborted) {
-              clearTimeout(timer);
-              frameResolve = null;
-              resolve();
-            } else {
-              signal.addEventListener("abort", onAbort, { once: true });
-            }
+          if (signal?.aborted) {
+            clearSleepTimer();
+            sleepResolve = null;
+            frameResolve = null;
+            resolve();
           }
         });
+        sleepResolve = null;
+        clearSleepTimer();
       }
     }
   } finally {
     closed = true;
+    if (signal) signal.removeEventListener("abort", handleAbort);
+    clearSleepTimer();
     try {
       await videoStream.stop();
     } catch {
@@ -7483,12 +7503,13 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         if (frame.videoType === "H264" || frame.videoType === "H265") {
           this.setFlowVideoType(frame.videoType, "native stream");
         }
-        this.flow.extractParameterSets(frame.data);
-        const { hasParamSets } = this.flow.getFmtp();
-        if (hasParamSets) {
+        if (!this.flow.getFmtp().hasParamSets) {
+          this.flow.extractParameterSets(frame.data);
+        }
+        if (this.flow.getFmtp().hasParamSets) {
           this.markFirstFrameReceived();
         }
-        const isKeyframe = this.isRawFrameKeyframe(frame);
+        const isKeyframe = typeof frame.isKeyframe === "boolean" ? frame.isKeyframe : this.isRawFrameKeyframe(frame);
         this.prebuffer.push({
           frame: { ...frame, data: Buffer.from(frame.data) },
           time: Date.now(),
@@ -8668,6 +8689,60 @@ function patchMotionSensitivityListXml(currentXml, bands) {
   );
 }
 
+// src/emailPush/bus.ts
+import { EventEmitter as EventEmitter4 } from "events";
+var emitter = new EventEmitter4();
+var cameraResolver = () => void 0;
+var lastEventByCamera = /* @__PURE__ */ new Map();
+var MAX_GLOBAL_EVENTS = 300;
+var globalRecentEvents = [];
+function setEmailPushCameraResolver(resolver) {
+  cameraResolver = resolver;
+}
+function getEmailPushCameraResolver() {
+  return cameraResolver;
+}
+function onEmailPushEvent(handler) {
+  emitter.on("event", handler);
+  return () => emitter.off("event", handler);
+}
+function emitEmailPushEvent(event) {
+  lastEventByCamera.set(event.cameraId, event);
+  globalRecentEvents.unshift(event);
+  if (globalRecentEvents.length > MAX_GLOBAL_EVENTS) {
+    globalRecentEvents.length = MAX_GLOBAL_EVENTS;
+  }
+  emitter.emit("event", event);
+}
+function getLastEmailPushEvent(cameraId) {
+  return lastEventByCamera.get(cameraId);
+}
+function getRecentEmailPushEvents(limit = MAX_GLOBAL_EVENTS) {
+  const clamped = Math.max(0, Math.min(limit, MAX_GLOBAL_EVENTS));
+  return globalRecentEvents.slice(0, clamped);
+}
+function mapEmailPushInferredType(inferred) {
+  switch (inferred) {
+    case "motion":
+    case "doorbell":
+    case "people":
+    case "vehicle":
+    case "animal":
+    case "face":
+    case "package":
+      return inferred;
+    case "other":
+    default:
+      return "motion";
+  }
+}
+function _resetEmailPushBusForTests() {
+  emitter.removeAllListeners();
+  cameraResolver = () => void 0;
+  lastEventByCamera.clear();
+  globalRecentEvents.length = 0;
+}
+
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
 import { spawn as spawn2 } from "child_process";
 import { mkdir } from "fs/promises";
@@ -11265,6 +11340,39 @@ var applyFloodlightSettingsToXml = (xml, settings) => {
   return modifiedXml;
 };
 
+// src/reolink/baichuan/utils/whiteLedStatusPush.ts
+var parseFloodlightStatusListPushXml = (xml) => {
+  const out = [];
+  const re = /<channel>\s*(\d+)\s*<\/channel>[\s\S]*?<status>\s*(\d+)\s*<\/status>/gi;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const channel = Number.parseInt(m[1] ?? "", 10);
+    const status = Number.parseInt(m[2] ?? "", 10);
+    if (!Number.isFinite(channel) || !Number.isFinite(status)) continue;
+    out.push({ channel, status });
+  }
+  return out;
+};
+
+// src/reolink/baichuan/utils/sirenStatusPush.ts
+var parseSirenStatusListPushXml = (xml) => {
+  const out = [];
+  const re = /<(?:channelId|channel)>\s*(\d+)\s*<\/(?:channelId|channel)>[\s\S]*?<status>\s*(\d+)\s*<\/status>(?:[\s\S]*?<playing>\s*(\d+)\s*<\/playing>)?/gi;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const channel = Number.parseInt(m[1] ?? "", 10);
+    const status = Number.parseInt(m[2] ?? "", 10);
+    if (!Number.isFinite(channel) || !Number.isFinite(status)) continue;
+    const entry = { channel, status };
+    if (m[3] !== void 0) {
+      const playing = Number.parseInt(m[3], 10);
+      if (Number.isFinite(playing)) entry.playing = playing;
+    }
+    out.push(entry);
+  }
+  return out;
+};
+
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
 var DUAL_LENS_DUAL_MOTION_MODELS = /* @__PURE__ */ new Set([
   "Reolink Duo PoE",
@@ -11410,7 +11518,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * general socket is created, logged in, and all event/push/guard listeners
    * are re-attached automatically.
    *
-   * This is a **no-op** when the API is already {@link isReady}.
+   * This is a **no-op** when the API is already ready (see `isReadyState()`).
    *
    * @throws If `close()` was called — the API is permanently closed and a new
    *         instance must be created.
@@ -11491,7 +11599,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   /**
    * Attach event, push, channelInfo, and guard listeners to the current
    * "general" client.  Called from the constructor and from
-   * {@link reconnectGeneralSocket}.
+   * `reconnectGeneralSocket()`.
    */
   setupGeneralClientListeners() {
     const client = this.client;
@@ -11543,7 +11651,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     });
     client.on("push", (frame) => {
       const cmdId = frame.header.cmdId;
-      if (cmdId !== BC_CMD_ID_PUSH_VIDEO_INPUT && cmdId !== BC_CMD_ID_PUSH_SERIAL && cmdId !== BC_CMD_ID_PUSH_NET_INFO && cmdId !== BC_CMD_ID_PUSH_DINGDONG_LIST && cmdId !== BC_CMD_ID_PUSH_SLEEP_STATUS && cmdId !== BC_CMD_ID_PUSH_COORDINATE_POINT_LIST) {
+      if (cmdId !== BC_CMD_ID_PUSH_VIDEO_INPUT && cmdId !== BC_CMD_ID_PUSH_SERIAL && cmdId !== BC_CMD_ID_PUSH_NET_INFO && cmdId !== BC_CMD_ID_PUSH_DINGDONG_LIST && cmdId !== BC_CMD_ID_PUSH_SLEEP_STATUS && cmdId !== BC_CMD_ID_PUSH_COORDINATE_POINT_LIST && cmdId !== BC_CMD_ID_FLOODLIGHT_STATUS_LIST && cmdId !== BC_CMD_ID_GET_AUDIO_ALARM) {
         return;
       }
       try {
@@ -13080,6 +13188,40 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       this.econnresetStormRebootInFlight = void 0;
     });
   }
+  /**
+   * Bind this API instance to the global email-push bus so that incoming
+   * SMTP-delivered motion / AI events for the matching camera surface on
+   * this instance's standard `onSimpleEvent` channel. The consumer keeps
+   * a single subscription (`onSimpleEvent`) and gets both the native
+   * Baichuan push and the email-push transport on the same stream.
+   *
+   * - `cameraId` shorthand: match events with `event.cameraId === cameraId`.
+   * - `match`: arbitrary predicate (e.g. when the consumer uses a
+   *   nickname-based mapping or wants to handle multiple recipients).
+   *
+   * Returns an `off()` handle. Safe to call repeatedly — each call
+   * registers its own listener.
+   */
+  subscribeEmailPushEvents(params) {
+    const channel = params.channel ?? 0;
+    const matches = "match" in params ? params.match : (event) => event.cameraId === params.cameraId;
+    const off = onEmailPushEvent((event) => {
+      if (!matches(event)) return;
+      this.dispatchSimpleEvent({
+        type: mapEmailPushInferredType(event.inferredType),
+        channel,
+        timestamp: event.receivedAtMs
+      });
+      if (event.inferredType !== "motion" && event.inferredType !== "doorbell" && event.inferredType !== "other") {
+        this.dispatchSimpleEvent({
+          type: "motion",
+          channel,
+          timestamp: event.receivedAtMs
+        });
+      }
+    });
+    return off;
+  }
   /**
    * Subscribe to minimal high-level events.
    * The API manages Baichuan subscribe/unsubscribe automatically.
@@ -13138,7 +13280,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Subscribe to per-frame detection events sourced from the BcMedia
    * `additionalHeader` block on active video streams.
    *
-   * Mirrors {@link onSimpleEvent} but is fed by the streaming side-channel:
+   * Mirrors `onSimpleEvent()` but is fed by the streaming side-channel:
    * one event fires for every I-frame / P-frame that carries an overlay block.
    * Coordinates are reported in normalized [0, 1] fractions of the source
    * frame, so the same box renders correctly on mainStream, subStream, and
@@ -13165,7 +13307,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Subscribe to AI object detections (people / vehicle / animal / face boxes
    * with class label and confidence) without managing a video stream yourself.
    *
-   * Mirrors {@link onSimpleEvent} end-to-end: on the first listener for a given
+   * Mirrors `onSimpleEvent()` end-to-end: on the first listener for a given
    * `(channel, profile)` tuple the API ensures the corresponding video stream
    * is running (the pool socket may already be shared with a regular consumer),
    * forwards every box-bearing `additionalHeader` to your callback, and tears
@@ -20009,7 +20151,7 @@ ${xml}`
    * Field meaning per stream:
    *  - `audio`           — 0/1 toggle
    *  - `width`/`height`  — resolution in pixels. Must be one of the
-   *                        resolutions returned by {@link getStreamInfoList}.
+   *                        resolutions returned by `getStreamInfoList()`.
    *  - `bitRate`         — kbps. Must match the table from `getStreamInfoList`.
    *  - `frameRate`       — fps. Must match the table from `getStreamInfoList`.
    *  - `videoEncType`    — `"h264"` or `"h265"`
@@ -20584,6 +20726,33 @@ ${xml}`
       };
       return;
     }
+    if (cmdId === BC_CMD_ID_FLOODLIGHT_STATUS_LIST) {
+      const entries = parseFloodlightStatusListPushXml(xml);
+      if (entries.length === 0) return;
+      for (const entry of entries) {
+        const channel = normalizePushChannel(entry.channel) ?? channelFromHeader;
+        getEntry(channel).floodlightStatus = {
+          updatedAtMs: now,
+          value: { status: entry.status === 1 }
+        };
+      }
+      return;
+    }
+    if (cmdId === BC_CMD_ID_GET_AUDIO_ALARM) {
+      const entries = parseSirenStatusListPushXml(xml);
+      if (entries.length === 0) return;
+      for (const entry of entries) {
+        const channel = normalizePushChannel(entry.channel) ?? channelFromHeader;
+        getEntry(channel).sirenStatus = {
+          updatedAtMs: now,
+          value: {
+            status: entry.status === 1,
+            ...entry.playing !== void 0 ? { playing: entry.playing === 1 } : {}
+          }
+        };
+      }
+      return;
+    }
   }
   /** Read-only snapshot of cached settings pushes (cmd_id 78/79/464/484/623/723). */
   getSettingsPushCacheSnapshot() {
@@ -20616,6 +20785,18 @@ ${xml}`
             ...entry.coordinatePointList,
             value: { ...entry.coordinatePointList.value }
           }
+        } : {},
+        ...entry.floodlightStatus ? {
+          floodlightStatus: {
+            ...entry.floodlightStatus,
+            value: { ...entry.floodlightStatus.value }
+          }
+        } : {},
+        ...entry.sirenStatus ? {
+          sirenStatus: {
+            ...entry.sirenStatus,
+            value: { ...entry.sirenStatus.value }
+          }
         } : {}
       });
     }
@@ -20639,6 +20820,29 @@ ${xml}`
   getCoordinatePointListFromPushCache(channel = 0) {
     return this.settingsPushCache.get(channel)?.coordinatePointList;
   }
+  /**
+   * Last cmd_id 291 (FloodlightStatusList) push observed for the channel.
+   * The camera emits this whenever the floodlight transitions on/off,
+   * including the auto-off after the FloodlightManual duration. This is
+   * the only reliable source for the current manual state because cmd 289
+   * only returns the FloodlightTask config.
+   *
+   * Returns undefined when no push has been received yet.
+   */
+  getCachedFloodlightStatus(channel = 0) {
+    return this.settingsPushCache.get(channel)?.floodlightStatus;
+  }
+  /**
+   * Last cmd_id 547 (SirenStatusList) push observed for the channel.
+   * Captures the actual on/off transitions including the firmware's
+   * built-in auto-off after the siren playback duration expires —
+   * polling cmd 547 alone can race that auto-off.
+   *
+   * Returns undefined when no push has been received yet.
+   */
+  getCachedSirenStatus(channel = 0) {
+    return this.settingsPushCache.get(channel)?.sirenStatus;
+  }
   // --------------------
   // PCAP-derived settings getters (typed wrappers)
   // --------------------
@@ -21336,10 +21540,12 @@ ${xml}`
     const triggers = params.triggerTypes ?? ["MD", "people", "vehicle"];
     const attachmentType = params.attachmentType ?? "picture";
     const interval = params.interval ?? 30;
+    const rawUser = params.authUsername ?? recipient;
+    const wireUser = rawUser.includes("@") ? rawUser : `${rawUser}@${domain}`;
     const emailPatch = {
       smtpServer: params.managerHost,
       smtpPort: port,
-      userName: params.authUsername ?? recipient,
+      userName: wireUser,
       password: params.authPassword ?? "",
       address1: recipient,
       address2: "",
@@ -24488,6 +24694,14 @@ export {
   patchAiDetectCfgXml,
   encodeMotionSensitivityListXml,
   patchMotionSensitivityListXml,
+  setEmailPushCameraResolver,
+  getEmailPushCameraResolver,
+  onEmailPushEvent,
+  emitEmailPushEvent,
+  getLastEmailPushEvent,
+  getRecentEmailPushEvents,
+  mapEmailPushInferredType,
+  _resetEmailPushBusForTests,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
   DUAL_LENS_MODELS,
@@ -24509,4 +24723,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-JYHK2ZSH.js.map
+//# sourceMappingURL=chunk-NQ7D5TLR.js.map