@mega-yfue/eufy-sdk 0.5.0-beta.44 → 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

@@ -620,7 +620,8 @@ function scanEntropy(tail, subsampling, extraTables) {
 // dist/transport/http/decodeImageV2.js
 import { decode as jpegDecode } from "jpeg-js";
 var V2_PREFIX = "v2_eufysecurity:";
-var DC_CHROMA = Buffer.from([255, 196, 0, 31, 1]);
+var DRI_SEGMENT = Buffer.from([255, 221, 0, 4]);
+var SOS_HEADER = Buffer.from([255, 218, 0, 12, 3]);
 var ZIGZAG = [
   0,
   1,
@@ -821,6 +822,9 @@ var QUANT_CHROMA = [
 ];
 var DHT_DC_LUMA = Buffer.from("ffc4001f0000010501010101010100000000000000000102030405060708090a0b", "hex");
 var DHT_AC_LUMA = Buffer.from("ffc400b5100002010303020403050504040000017d01020300041105122131410613516107227114328191a1082342b1c11552d1f02433627282090a161718191a25262728292a3435363738393a434445464748494a535455565758595a636465666768696a737475767778797a838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae1e2e3e4e5e6e7e8e9eaf1f2f3f4f5f6f7f8f9fa", "hex");
+var DHT_DC_CHROMA = Buffer.from("ffc4001f0100030101010101010101010000000000000102030405060708090a0b", "hex");
+var DC_CHROMA = DHT_DC_CHROMA.subarray(0, 5);
+var DHT_AC_CHROMA = Buffer.from("ffc400b51100020102040403040705040400010277000102031104052131061241510761711322328108144291a1b1c109233352f0156272d10a162434e125f11718191a262728292a35363738393a434445464748494a535455565758595a636465666768696a737475767778797a82838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae2e3e4e5e6e7e8e9eaf2f3f4f5f6f7f8f9fa", "hex");
 var SOI = Buffer.from([255, 216]);
 var APP0 = Buffer.from("ffe000104a46494600010100000100010000", "hex");
 var MCU = { 0: [8, 8], 1: [16, 8], 2: [16, 16] };
@@ -973,16 +977,31 @@ function findGeometry(tail) {
   }
   return best;
 }
+function findScanCut(data) {
+  const sos = data.lastIndexOf(SOS_HEADER);
+  if (sos < 0)
+    return -1;
+  const dri = sos - DRI_SEGMENT.length - 2;
+  return dri >= 0 && data.subarray(dri, dri + DRI_SEGMENT.length).equals(DRI_SEGMENT) ? dri : -1;
+}
+function plaintextTail(data) {
+  const cut = data.indexOf(DC_CHROMA);
+  if (cut >= 0)
+    return data.subarray(cut);
+  const scan = findScanCut(data);
+  if (scan < 0)
+    return null;
+  return Buffer.concat([DHT_DC_CHROMA, DHT_AC_CHROMA, data.subarray(scan)]);
+}
 function isV2Image(data) {
   return data.length >= V2_PREFIX.length && data.subarray(0, V2_PREFIX.length).toString("latin1") === V2_PREFIX;
 }
 function decodeImageV2(data) {
   if (!isV2Image(data))
     return null;
-  const cut = data.indexOf(DC_CHROMA);
-  if (cut < 0)
+  const tail = plaintextTail(data);
+  if (!tail)
     return null;
-  const tail = data.subarray(cut);
   const geometry = findGeometry(tail);
   if (!geometry)
     return null;
@@ -22705,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;
@@ -22814,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) {
@@ -22885,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;
@@ -23421,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))
@@ -23459,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);
     });
   }
@@ -23770,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);
@@ -23965,6 +23992,7 @@ var RtcCommandRouter = class {
   deps;
   sessions = /* @__PURE__ */ new Map();
   lives = /* @__PURE__ */ new Map();
+  warm = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -24214,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);
@@ -28974,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) {