@mega-yfue/eufy-sdk 0.4.0-beta.0 → 0.4.0-beta.10

package/dist/client/eufy-mega.d.ts

@@ -871,7 +871,10 @@ export declare class EufyMega extends EventEmitter {
      * one — so this never overwrites a channel a later login already brought up.
      */
     private startPush;
-    /** Admit only exact, account-known devices with resolved snapshot evidence into the passive store. */
+    /**
+     * Admit only exact, account-known devices with resolved snapshot evidence into the passive store; a
+     * station-only candidate is admitted under the event's device serial.
+     */
     private observeStoredImage;
     /**
      * Tear down every realtime channel: close the secure-MQTT transport, all P2P sessions, and the FCM

package/dist/core/contracts.d.ts

@@ -684,8 +684,8 @@ export interface SharedSourceHints {
      */
     powered?: "wired" | "battery";
     /**
-     * Seconds of already-captured media the pull retains for a later drain; `0`, absent, non-finite and
-     * negative values retain none.
+     * Seconds of already-captured media the pull retains for a later drain; `0`, absent, non-finite,
+     * negative, and windows longer than 2,147,483,647 ms retain none.
      *
      * Retention costs memory on every frame and only a caller knows whether anything will drain it, so it
      * is never assumed. Media can only be retained while the pull is running, so a window answers "what did

package/dist/index.js

@@ -2125,6 +2125,10 @@ function solixUserTopics(appName, userId) {
 
 // dist/transport/mqtt/secure-mqtt.js
 var SUBACK_FAILURE = 128;
+function isRefusal(err) {
+  const granted = err?.packet?.granted;
+  return Array.isArray(granted) && granted.some((g) => typeof g === "number" && (g & SUBACK_FAILURE) !== 0);
+}
 function isNotAuthorized(err) {
   return err instanceof Error && /connection refused/i.test(err.message) && /not authori[sz]ed/i.test(err.message);
 }
@@ -2227,19 +2231,16 @@ var SecureMqtt = class extends EventEmitter {
   }
   /**
    * Subscribe every inbound leg this device's line uses (see `topics.ts` — one `/res` for most lines,
-   * four topics for `eufy_life`).
+   * four topics for `eufy_life` and the clean line).
    *
-   * The grants are INSPECTED, not assumed: AWS IoT answers a policy-denied filter with a
-   * SUBACK_FAILURE (`0x80`) grant rather than failing the SUBSCRIBE, so subscribing with a credential
-   * whose scope doesn't cover the topic looks identical to success and then delivers nothing. A denied
-   * topic is reported via `error` naming the credential scope; only an all-denied device throws, so a
-   * line that grants its state channel but refuses (say) the OTA leg still works.
+   * The grants are INSPECTED, not assumed: AWS IoT refuses a policy-denied filter with a
+   * {@link SUBACK_FAILURE} grant rather than failing the connection. A denied topic is reported via
+   * `error` naming the credential scope; only an all-denied device throws, so a line that grants its
+   * state channel but refuses (say) a business leg still works.
    */
   async subscribeDevice(device) {
-    if (!this.client)
-      throw new Error("SecureMqtt not connected");
     const topics = [...subscribeTopics(device)];
-    const { denied } = this.partitionGrants(await this.client.subscribeAsync(topics, { qos: 1 }));
+    const { denied } = await this.subscribeEach(topics);
     const scope = this.o.credentials.app_name ?? "default";
     if (denied.length === topics.length) {
       throw new Error(`subscribe ${device.sn}: every topic denied on credential scope "${scope}" \u2014 this line's topics are granted to a different scope (${denied.join(", ")})`);
@@ -2250,25 +2251,43 @@ var SecureMqtt = class extends EventEmitter {
   }
   /**
    * Subscribe to explicit topic filters, returning the topics that were granted. A scope-denied filter
-   * comes back with SUBACK_FAILURE rather than an error (AWS IoT quirk), so it is dropped from the result
-   * instead of throwing — callers that need every leg check the returned list. Used by lines whose topic
-   * vocabulary isn't the eufy `subscribeTopics` shape (e.g. Anker Solix `dt/{app}/{pn}/{sn}`).
+   * is dropped from the result instead of throwing — callers that need every leg check the returned
+   * list. Used by lines whose topic vocabulary isn't the eufy `subscribeTopics` shape (e.g. Anker Solix
+   * `dt/{app}/{pn}/{sn}`).
    */
   async subscribe(topics) {
-    if (!this.client)
-      throw new Error("SecureMqtt not connected");
-    return this.partitionGrants(await this.client.subscribeAsync(topics, { qos: 1 })).granted;
+    return (await this.subscribeEach(topics)).granted;
   }
   /**
-   * Split SUBACK grants into granted vs scope-denied topics. AWS IoT marks a policy-denied filter with a
-   * SUBACK_FAILURE (`0x80`) grant rather than failing the SUBSCRIBE, so the two subscribe paths share
-   * this split and layer their own policy (drop vs report) on top.
+   * Subscribe each filter in a SUBSCRIBE of its own and split the outcome into granted vs refused.
+   *
+   * One request per filter because the MQTT engine treats a SUBACK as all-or-nothing: one refused grant
+   * rejects the whole request, and it forgets EVERY filter of that request for resubscription after a
+   * reconnect — so a batch holding one denied leg would lose the granted legs on the next drop. Alone,
+   * a refused filter costs only itself. A rejection that carries no SUBACK is a transport failure and
+   * is thrown.
+   *
+   * The cost is one SUBSCRIBE and one SUBACK per filter instead of one per device — four for a
+   * four-leg line. They are sent concurrently, so the wall-clock cost is one round trip. Folding them
+   * back into one request brings back the lost resubscription.
    */
-  partitionGrants(grants) {
+  async subscribeEach(topics) {
+    const client = this.client;
+    if (!client)
+      throw new Error("SecureMqtt not connected");
+    const outcomes = await Promise.allSettled(topics.map((topic) => client.subscribeAsync(topic, { qos: 1 })));
     const granted = [];
     const denied = [];
-    for (const g of grants)
-      (g.qos === SUBACK_FAILURE ? denied : granted).push(g.topic);
+    outcomes.forEach((outcome, i) => {
+      const topic = topics[i];
+      if (outcome.status === "fulfilled") {
+        granted.push(topic);
+        return;
+      }
+      if (!isRefusal(outcome.reason))
+        throw outcome.reason;
+      denied.push(topic);
+    });
     return { granted, denied };
   }
   /**
@@ -4326,7 +4345,7 @@ function decodePowerSource(raw) {
 function recordSetting(param, value, ctx) {
   return setStationScalar(param, value, ctx.channel);
 }
-var MAINS_CAMERA_MODELS = ["T8425", "T8419", "T8410", "T84A1"];
+var MAINS_CAMERA_MODELS = ["T8425", "T8419", "T8410", "T84A1", "T8423"];
 function cameraPowerTier(model, capabilities) {
   return capabilities.has("battery") && notMainsCamera({ model }) ? "battery" : "wired";
 }
@@ -15159,6 +15178,7 @@ var LOCAL_LOOKUP_PORT = 32108;
 var HEARTBEAT_MS = 5e3;
 var PATH_SILENCE_MS = HEARTBEAT_MS * 3;
 var LOOKUP_RETRY_MS = 1e3;
+var RECEIVE_BUFFER_BYTES = 4 * 1024 * 1024;
 var CONNECT_TIMEOUT_MS = 15e3;
 var STATION_CHANNEL3 = 255;
 var CMD_GATEWAYINFO = 1100;
@@ -15188,6 +15208,7 @@ var REORDER_MAX_DATAGRAMS = 128;
 var MAX_TRACED_DATAGRAM_GAPS = 8;
 var CMD_SET_PAYLOAD = 1350;
 var CMD_NOTIFY_PAYLOAD = 1351;
+var PADDED_RESULT_BYTES = 132;
 var CMD_CAMERA_INFO = 1103;
 var CMD_DATABASE_IMAGE = 1308;
 var CMD_DATABASE = 1306;
@@ -15213,6 +15234,8 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   connected = false;
   connecting = false;
   closed = false;
+  /** Whether a short receive buffer has been reported, so a reconnect does not repeat the same warning. */
+  receiveBufferReported = false;
   connectAddress;
   seqNumber = 0;
   /**
@@ -15252,7 +15275,10 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   cloudLookup;
   /** Local outbound IPv4 reported inside LOOKUP_WITH_KEY requests. */
   selfHost;
-  /** In-flight multi-datagram frame per data channel (see onData). */
+  /**
+   * In-flight multi-datagram frame per data channel (see reassemble): the payload gathered so far under its
+   * parsed header, or, without a header, the start of a frame header cut by the datagram boundary.
+   */
   pendingByDataType = /* @__PURE__ */ new Map();
   /** Last delivered datagram sequence number per data type. */
   lastSeqByType = /* @__PURE__ */ new Map();
@@ -15532,6 +15558,26 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   get isConnected() {
     return this.connected;
   }
+  /**
+   * Ask the OS for {@link RECEIVE_BUFFER_BYTES} on a bound socket, and warn once per session when it grants
+   * less or refuses.
+   *
+   * The request is made here rather than through `createSocket`'s `recvBufferSize`: Node applies that option
+   * inside the bind callback, where a refusal is thrown out of reach of this session and ends the process.
+   */
+  requestReceiveBuffer(socket) {
+    let granted;
+    try {
+      socket.setRecvBufferSize(RECEIVE_BUFFER_BYTES);
+      granted = socket.getRecvBufferSize();
+    } catch {
+      granted = 0;
+    }
+    if (granted >= RECEIVE_BUFFER_BYTES || this.receiveBufferReported)
+      return;
+    this.receiveBufferReported = true;
+    this.logger.warn(`[p2p] ${this.cfg.stationSn} UDP receive buffer below the ${RECEIVE_BUFFER_BYTES} bytes requested` + (granted > 0 ? ` (granted ${granted})` : " (request refused)") + `; live video can lose keyframes. Raise the OS limit (net.core.rmem_max on Linux, kern.ipc.maxsockbuf on BSD) to at least ${RECEIVE_BUFFER_BYTES}.`);
+  }
   /** Open the socket and start the lookup → hole-punch handshake. */
   async connect() {
     if (this.connecting || this.connected)
@@ -15555,6 +15601,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
           socket.setBroadcast(true);
         } catch {
         }
+        this.requestReceiveBuffer(socket);
         resolve();
       });
     });
@@ -16627,7 +16674,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     clearTimeout(reorder.timer);
     reorder.timer = void 0;
   }
-  /** Reassemble one in-sequence datagram body into logical frames. */
+  /**
+   * Reassemble one in-sequence datagram body into logical frames.
+   *
+   * Frames are packed back to back, so a frame header can itself be cut by a datagram boundary. The start
+   * of a header left at the end of a datagram is carried into the next one rather than discarded; dropping
+   * it would lose that frame and every frame after it until a datagram happened to begin on a header.
+   */
   reassemble(dataType, datagramBody) {
     const pending = this.pendingByDataType.get(dataType);
     let body = pending ? Buffer.concat([pending.buf, datagramBody]) : datagramBody;
@@ -16651,6 +16704,9 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       this.handleFrame(header, payload.subarray(0, header.bytesToRead), dataType);
       body = body.subarray(P2P_DATA_HEADER_BYTES + header.bytesToRead);
     }
+    if (body.length > 0 && body.length < P2P_DATA_HEADER_BYTES && MAGIC_WORD.startsWith(body.subarray(0, 4).toString())) {
+      this.pendingByDataType.set(dataType, { buf: body });
+    }
   }
   /**
    * Forget where each data type's sequence numbering had reached, and drop any half-reassembled frame.
@@ -16735,7 +16791,8 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
         this.emit("error", e instanceof Error ? e : new Error(String(e)));
       }
     }
-    if (!isMedia && !frame.json && data.length === 4) {
+    const paddedResult = header.commandId === CMD_SET_PAYLOAD && data.length === PADDED_RESULT_BYTES && data.subarray(4).every((b) => b === 0);
+    if (!isMedia && !frame.json && (data.length === 4 || paddedResult)) {
       this.emit("commandResult", { code: data.readInt32LE(0), channel: header.channel });
     }
     this.emit("data", frame);
@@ -18164,9 +18221,9 @@ function annexbToJpeg(annexb, spawn2) {
 
 // dist/transport/p2p/shared-live-source.js
 import { EventEmitter as EventEmitter4 } from "node:events";
-function durationMs(seconds) {
-  const milliseconds = (seconds ?? 0) * 1e3;
-  return Number.isFinite(milliseconds) && milliseconds > 0 ? milliseconds : 0;
+var MAX_TIMER_DELAY_MS = 2147483647;
+function timerMs(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value >= 1 && value <= MAX_TIMER_DELAY_MS ? value : fallback;
 }
 function sameConfig(a, b) {
   return b !== void 0 && a.codec === b.codec && a.width === b.width && a.height === b.height;
@@ -18419,14 +18476,14 @@ var SharedLiveSource = class {
   tag;
   constructor(opts) {
     this.opts = opts;
-    this.lingerMs = opts.lingerMs ?? 8e3;
+    this.lingerMs = opts.lingerMs === 0 ? 1 : timerMs(opts.lingerMs, 8e3);
     this.maxQueue = opts.maxQueue ?? 900;
-    this.preBufferMs = durationMs(opts.preBufferSeconds);
-    this.warmRetryMs = opts.warmRetryMs ?? 2e3;
-    this.warmTimeoutMs = opts.warmTimeoutMs ?? 2e4;
+    this.preBufferMs = timerMs((opts.preBufferSeconds ?? 0) * 1e3, 0);
+    this.warmRetryMs = timerMs(opts.warmRetryMs, 2e3);
+    this.warmTimeoutMs = timerMs(opts.warmTimeoutMs, 2e4);
     this.powered = opts.powered ?? "wired";
-    this.batteryBudgetMs = opts.batteryBudgetMs ?? 45e3;
-    this.budgetGraceMs = opts.budgetGraceMs ?? 1e4;
+    this.batteryBudgetMs = timerMs(opts.batteryBudgetMs, 45e3);
+    this.budgetGraceMs = timerMs(opts.budgetGraceMs, 1e4);
     this.logger = opts.logger ?? noopLogger;
     this.tag = opts.label ? `[live ${opts.label}]` : "[live]";
     this.traceId = `pull-${++pullSequence}`;
@@ -18674,7 +18731,7 @@ var SharedLiveSource = class {
     if (this.disposed || !this.stream)
       return;
     this.clearBudget();
-    this.budgetTimer.arm(ms ?? this.batteryBudgetMs, () => this.onBudgetExpire());
+    this.budgetTimer.arm(timerMs(ms, this.batteryBudgetMs), () => this.onBudgetExpire());
   }
   /** Settle a reuse watch on any frame — the join already holds a decodable picture. */
   settleReuseWatch() {
@@ -18815,7 +18872,7 @@ var SharedLiveSource = class {
     return this.bufferedMedia(seconds).filter((item) => item.kind === "video").map((item) => item.frame);
   }
   bufferedMedia(seconds) {
-    const requested = Math.min(durationMs(seconds), this.preBufferMs);
+    const requested = Number.isFinite(seconds) ? Math.min(seconds * 1e3, this.preBufferMs) : 0;
     if (requested <= 0 || !this.ring.length)
       return [];
     const start = this.windowStart(Date.now() - requested);
@@ -26837,7 +26894,7 @@ var EufyMega = class extends EventEmitter9 {
       if (ev.eventName === void 0 && ev.eventType != null)
         ev.eventName = detectionName(ev.eventType);
       if (ev.thumbnailCandidate)
-        void this.observeStoredImage(ev.thumbnailCandidate);
+        void this.observeStoredImage(ev.thumbnailCandidate, ev.deviceSn);
       this.emit("push", ev);
       const signal2 = {
         source: "push",
@@ -26886,9 +26943,16 @@ var EufyMega = class extends EventEmitter9 {
     client.on("error", (e) => this.reportError(e));
     return client;
   }
-  /** Admit only exact, account-known devices with resolved snapshot evidence into the passive store. */
-  async observeStoredImage(candidate) {
-    if (!this.storedImages || candidate.attribution.kind !== "device")
+  /**
+   * Admit only exact, account-known devices with resolved snapshot evidence into the passive store; a
+   * station-only candidate is admitted under the event's device serial.
+   */
+  async observeStoredImage(candidate, eventDeviceSn) {
+    if (!this.storedImages)
+      return;
+    const { attribution } = candidate;
+    const deviceSn = attribution.kind === "device" ? attribution.deviceSn : attribution.kind === "station" ? eventDeviceSn : void 0;
+    if (!deviceSn)
       return;
     const account = this.mega.auth?.userId;
     if (!account)
@@ -26898,9 +26962,9 @@ var EufyMega = class extends EventEmitter9 {
         await this.registry.getDevices();
       if (this.mega.auth?.userId !== account)
         return;
-      const caps = this.registry.capabilitiesForDevice(candidate.attribution.deviceSn);
+      const caps = this.registry.capabilitiesForDevice(deviceSn);
       if (caps && hasProvidedAction(caps, "snapshotStored")) {
-        this.storedImages.observe(candidate.attribution.deviceSn, candidate.url);
+        this.storedImages.observe(deviceSn, candidate.url);
       }
     } catch (e) {
       this.reportError(e);