@mega-yfue/eufy-sdk 0.5.0-beta.45 → 0.5.0-beta.46

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

@@ -711,6 +711,11 @@ export declare class EufyMega extends EventEmitter {
      * — an already-open session resolves immediately.
      */
     connectStation(deviceSn: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * Keep a T9000 station's RTC command session open and warm, so a command fires without a cold reconnect.
+     * Answers the hold's disposer; throws for any other station, and while logged out.
+     */
+    keepStationWarm(stationSn: string): () => void;
     /** Eagerly open P2P sessions for WIRED stations only (persistent — they don't drain). Battery
      *  stations stay closed until an on-demand open. Best-effort per station. */
     private warmWiredP2P;

package/dist/index.js

@@ -22724,6 +22724,10 @@ var P2PCommandRouter = class _P2PCommandRouter {
 // dist/transport/rtc/live.js
 import { EventEmitter as EventEmitter7 } from "node:events";
 
+// dist/transport/rtc/portal-keepalive.js
+var PORTAL_KEEPALIVE = Buffer.from("0009000010000000000000006300000000000000585a5948730400000000000000000002", "hex");
+var PORTAL_KEEPALIVE_MS = 29e3;
+
 // dist/transport/rtc/portal-packet.js
 var MAGIC2 = Buffer.from("XZYH", "ascii");
 var PORTAL_HEADER_LENGTH = 16;
@@ -22833,8 +22837,6 @@ var LIVE_STOP = 1004;
 var LIVE_MEDIA = 1300;
 var LIVE_MEDIA_CHANNEL = 101;
 var LIVE_STREAM_ID = 1;
-var KEEPALIVE_MS = 29e3;
-var KEEPALIVE = Buffer.from("0009000010000000000000006300000000000000585a5948730400000000000000000002", "hex");
 var MEDIA_HEADER_LENGTH = 22;
 var STREAM_TYPE_HEVC = 1;
 function parseMediaBody(body) {
@@ -22904,9 +22906,9 @@ var RtcLiveStream = class extends EventEmitter7 {
       return this;
     }
     this.keepalive = setInterval(() => {
-      if (!session.sendRaw(KEEPALIVE))
+      if (!session.sendRaw(PORTAL_KEEPALIVE))
         this.opts.logger?.warn?.(`[rtc] ${this.tag} keepalive not sent`);
-    }, KEEPALIVE_MS);
+    }, PORTAL_KEEPALIVE_MS);
     this.keepalive.unref?.();
     this.opts.logger?.debug?.(`[rtc] ${this.tag} live start sent`);
     return this;
@@ -23440,7 +23442,8 @@ var RtcPeer = class extends EventEmitter8 {
   }
   /**
    * Wire one data channel. Every channel feeds the framer once the command channel has opened it; a
-   * message before that has nothing to reassemble into and is dropped.
+   * message before that has nothing to reassemble into and is dropped. The hub's echo of the portal
+   * keepalive on the command channel is unframed and surfaces as `keepaliveEcho` instead.
    */
   wireChannel(label, dc) {
     if (this.channels.has(label))
@@ -23478,6 +23481,10 @@ var RtcPeer = class extends EventEmitter8 {
       if (n <= 3 || n % 100 === 0) {
         this.logger.debug(`[rtc] wire ${label} #${n} ${buf.length}B ${buf.subarray(0, 8).toString("hex")}`);
       }
+      if (label === COMMAND_CHANNEL && buf.equals(PORTAL_KEEPALIVE)) {
+        this.emit("keepaliveEcho");
+        return;
+      }
       this.framer?.recvPacket(buf);
     });
   }
@@ -23789,6 +23796,7 @@ var RtcSession = class extends EventEmitter10 {
       }
     });
     this.peer.on("error", (e) => this.emit("error", e));
+    this.peer.on("keepaliveEcho", () => this.emit("keepaliveEcho"));
     this.peer.on("data", (frame, linkType) => {
       if (linkType === PortalLinkType.LIVE)
         this.emit("mediaData", frame);
@@ -23984,6 +23992,7 @@ var RtcCommandRouter = class {
   deps;
   sessions = /* @__PURE__ */ new Map();
   lives = /* @__PURE__ */ new Map();
+  warm = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -24233,6 +24242,96 @@ var RtcCommandRouter = class {
       Promise.resolve().then(() => session.connect()).catch((e) => finish(e instanceof Error ? e : new Error(String(e))));
     });
   }
+  /**
+   * Hold a station's command session open: one hold per station, its idle-close ({@link IDLE_CLOSE_MS})
+   * suppressed, {@link PORTAL_KEEPALIVE} sent every {@link PORTAL_KEEPALIVE_MS}, and the session dropped
+   * on a tick that finds the previous keepalive unechoed. A closed session ends the hold.
+   *
+   * Answers an idempotent disposer that releases the hold. Throws when no account is logged in.
+   */
+  keepWarm(route) {
+    const sn = route.stationSn;
+    const existing = this.warm.get(sn);
+    if (existing)
+      return existing.dispose;
+    const identity = this.deps.identity();
+    if (!identity)
+      throw new Error(`rtc: not logged in, cannot warm ${sn}`);
+    const hold = {
+      awaitingEcho: false,
+      dispose: () => {
+        if (this.warm.get(sn) !== hold)
+          return;
+        this.warm.delete(sn);
+        const st = hold.watch?.st;
+        this.unwatch(hold);
+        if (st) {
+          st.leases = Math.max(0, st.leases - 1);
+          this.touch(sn, st);
+        }
+      }
+    };
+    this.warm.set(sn, hold);
+    void this.warmUp(sn, route, identity, hold);
+    return hold.dispose;
+  }
+  /**
+   * Bring a station session up for a {@link keepWarm} hold and start its keepalive. A bring-up that fails,
+   * or a hold disposed before it completes, clears the hold and arms no timer. Each tick first checks
+   * that the hub echoed the previous keepalive, and drops the session when it did not. The keepalive
+   * stops when the session closes, which also clears the hold so the next command or `keepWarm`
+   * rebuilds cleanly.
+   */
+  async warmUp(sn, route, identity, hold) {
+    const adminUserId = route.adminUserId || identity.userId;
+    let st;
+    try {
+      st = await this.stationSession(route, adminUserId, identity);
+    } catch (e) {
+      if (this.warm.get(sn) === hold)
+        this.warm.delete(sn);
+      this.deps.onError?.(e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    if (this.warm.get(sn) !== hold) {
+      this.touch(sn, st);
+      return;
+    }
+    st.leases++;
+    this.touch(sn, st);
+    const onClose = () => {
+      this.unwatch(hold);
+      if (this.warm.get(sn) === hold)
+        this.warm.delete(sn);
+    };
+    const onEcho = () => {
+      hold.awaitingEcho = false;
+    };
+    hold.watch = { st, onClose, onEcho };
+    st.session.once("close", onClose);
+    st.session.on("keepaliveEcho", onEcho);
+    hold.keepalive = setInterval(() => {
+      if (hold.awaitingEcho) {
+        this.deps.logger?.warn?.(`[rtc] ${sn} warm keepalive went unechoed, dropping the session`);
+        this.drop(sn, st);
+        return;
+      }
+      hold.awaitingEcho = true;
+      st.session.sendRaw(PORTAL_KEEPALIVE);
+    }, PORTAL_KEEPALIVE_MS);
+    hold.keepalive.unref?.();
+  }
+  /** Stop a hold's keepalive and remove its listeners from the session it watches. */
+  unwatch(hold) {
+    if (hold.keepalive)
+      clearInterval(hold.keepalive);
+    hold.keepalive = void 0;
+    if (hold.watch) {
+      hold.watch.st.session.off("close", hold.watch.onClose);
+      hold.watch.st.session.off("keepaliveEcho", hold.watch.onEcho);
+    }
+    hold.watch = void 0;
+  }
   touch(sn, st) {
     if (st.idle)
       clearTimeout(st.idle);
@@ -28993,6 +29092,17 @@ var EufyMega = class extends EventEmitter13 {
       await this.getDevices();
     await this.p2p.ensureStation(this.p2p.stationKeyOf(deviceSn), signal);
   }
+  /**
+   * Keep a T9000 station's RTC command session open and warm, so a command fires without a cold reconnect.
+   * Answers the hold's disposer; throws for any other station, and while logged out.
+   */
+  keepStationWarm(stationSn) {
+    const { t9000 } = this.stationOf(stationSn);
+    const route = this.rtcRouteFor(stationSn);
+    if (!t9000 || !route)
+      throw new Error(`rtc: ${stationSn} has no warm command session`);
+    return this.rtc.keepWarm(route);
+  }
   /** Eagerly open P2P sessions for WIRED stations only (persistent — they don't drain). Battery
    *  stations stay closed until an on-demand open. Best-effort per station. */
   async warmWiredP2P(readiness = createPlaneReadiness(), signal) {