@mega-yfue/eufy-sdk 0.3.0-beta.0 → 0.3.0-beta.2

package/dist/index.js

@@ -5813,6 +5813,7 @@ var LIGHT_SWITCH_JSON_TYPES = /* @__PURE__ */ new Set([
   DeviceType.CAMERA_4G_S330
 ]);
 var LIGHT_SWITCH_INT_STRING_TYPES = /* @__PURE__ */ new Set([
+  DeviceType.FLOODLIGHT_CAMERA_8423,
   DeviceType.INDOOR_OUTDOOR_CAMERA_1080P_NO_LIGHT,
   DeviceType.INDOOR_OUTDOOR_CAMERA_2K,
   DeviceType.INDOOR_OUTDOOR_CAMERA_1080P,
@@ -15139,6 +15140,7 @@ var LIVE_START_RETRANSMIT_MS = 150;
 var LIVE_START_ACK_DEADLINE_MS = 3e3;
 var SEQUENCE_LOOKBACK = 32768;
 var STALE_RETRANSMIT_DEPTH = 1024;
+var PUNCH_PROBE_SOCKETS = 7;
 var MAX_TRACED_DATAGRAM_GAPS = 8;
 var CMD_SET_PAYLOAD = 1350;
 var CMD_NOTIFY_PAYLOAD = 1351;
@@ -15200,8 +15202,12 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   lookupTimer;
   heartbeatTimer;
   connectTimer;
-  /** Our own bound host:port, self-reported inside LOOKUP_WITH_KEY requests (see sendLookups). */
-  selfAddress;
+  /** Extra sockets registered alongside {@link socket} while connecting; see {@link PUNCH_PROBE_SOCKETS}. */
+  probeSockets = [];
+  /** Cloud lookup inputs resolved once for a connection. */
+  cloudLookup;
+  /** Local outbound IPv4 reported inside LOOKUP_WITH_KEY requests. */
+  selfHost;
   /** In-flight multi-datagram frame per data channel (see onData). */
   pendingByDataType = /* @__PURE__ */ new Map();
   /** Last datagram sequence number seen per dataType — used to detect a lost/reordered datagram
@@ -15496,7 +15502,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     }
     const socket = dgram.createSocket("udp4");
     this.socket = socket;
-    socket.on("message", (msg, rinfo) => this.onMessage(msg, rinfo));
+    socket.on("message", (msg, rinfo) => this.onMessage(msg, rinfo, socket));
     socket.on("error", (e) => this.emit("error", e));
     await new Promise((resolve) => {
       socket.bind(() => {
@@ -15507,15 +15513,20 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
         resolve();
       });
     });
-    const boundPort = socket.address().port;
     void _P2PSession.detectLocalIp().then((host) => {
       if (host && !this.closed)
-        this.selfAddress = { host, port: boundPort };
+        this.selfHost = host;
     });
+    const { dskKey, cloudAddresses } = this.cfg;
+    this.cloudLookup = dskKey && cloudAddresses?.length ? { key: dskKey, addresses: cloudAddresses } : void 0;
+    if (this.cloudLookup)
+      await this.startPunchProbes();
+    if (this.closed)
+      return;
     this.trace({
       phase: "lookup-channels",
       local: !this.cfg.noBroadcast || this.cfg.localAddress !== void 0,
-      cloud: this.cfg.dskKey !== void 0 && (this.cfg.cloudAddresses?.length ?? 0) > 0
+      cloud: this.cloudLookup !== void 0
     });
     this.sendLookups();
     this.lookupTimer = setInterval(() => this.sendLookups(), LOOKUP_RETRY_MS);
@@ -15593,14 +15604,20 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       this.send({ host: "255.255.255.255", port: LOCAL_LOOKUP_PORT }, RequestMessageType.LOCAL_LOOKUP, localPayload);
     if (this.cfg.localAddress)
       this.send({ host: this.cfg.localAddress, port: LOCAL_LOOKUP_PORT }, RequestMessageType.LOCAL_LOOKUP, localPayload);
-    if (this.cfg.dskKey && this.cfg.cloudAddresses?.length) {
-      const payload = this.selfAddress ? buildLookupWithKeyPayload(this.cfg.p2pDid, this.selfAddress.host, this.selfAddress.port, this.cfg.dskKey) : buildLookupWithKeyPayload2(this.cfg.p2pDid, this.cfg.dskKey);
-      const type = this.selfAddress ? RequestMessageType.LOOKUP_WITH_KEY : RequestMessageType.LOOKUP_WITH_KEY2;
-      for (const addr of this.cfg.cloudAddresses)
-        this.send(addr, type, payload);
-      this.logger.debug(`[p2p] ${this.cfg.stationSn} sendLookups: cloud -> ${this.cfg.cloudAddresses.map((a) => `${a.host}:${a.port}`).join(", ")} self=${this.selfAddress?.host}:${this.selfAddress?.port}`);
+    const lookup2 = this.cloudLookup;
+    if (lookup2) {
+      for (const socket of [this.socket, ...this.probeSockets])
+        this.sendCloudLookup(socket, lookup2);
+      this.logger.debug(`[p2p] ${this.cfg.stationSn} sendLookups: cloud -> ${lookup2.addresses.map((a) => `${a.host}:${a.port}`).join(", ")} self=${this.selfHost ?? "unknown"}`);
     }
   }
+  /** Register a bound socket's own port with each configured cloud lookup address. */
+  sendCloudLookup(socket, lookup2) {
+    const payload = this.selfHost ? buildLookupWithKeyPayload(this.cfg.p2pDid, this.selfHost, socket.address().port, lookup2.key) : buildLookupWithKeyPayload2(this.cfg.p2pDid, lookup2.key);
+    const type = this.selfHost ? RequestMessageType.LOOKUP_WITH_KEY : RequestMessageType.LOOKUP_WITH_KEY2;
+    for (const addr of lookup2.addresses)
+      this.send(addr, type, payload, socket);
+  }
   /**
    * Route one inbound UDP datagram by its message type, tracing every non-DATA one and any type this session
    * does not model.
@@ -15612,28 +15629,30 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * recur across later probes of it. Correlate an unmodelled type against a WORKING session before reading it
    * as a cause.
    */
-  onMessage(msg, rinfo) {
+  onMessage(msg, rinfo, socket = this.socket) {
+    if (!socket)
+      return;
     if (!hasHeader(msg, ResponseMessageType.DATA)) {
       this.logger.debug(`[p2p] ${this.cfg.stationSn} <<< ${rinfo.address}:${rinfo.port} header=${msg.subarray(0, 2).toString("hex")} len=${msg.length}`);
     }
     if (hasHeader(msg, ResponseMessageType.LOCAL_LOOKUP_RESP)) {
       if (!this.connected)
-        this.beginCheckCam({ host: rinfo.address, port: rinfo.port });
+        this.beginCheckCam({ host: rinfo.address, port: rinfo.port }, socket);
     } else if (hasHeader(msg, ResponseMessageType.LOOKUP_ADDR) || hasHeader(msg, ResponseMessageType.LOOKUP_ADDR2)) {
       if (!this.connected) {
         const addr = parseLookupAddr(msg);
         this.logger.debug(`[p2p] ${this.cfg.stationSn} LOOKUP_ADDR -> ${addr.host}:${addr.port}`);
         if (addr.host !== "0.0.0.0")
-          this.beginCheckCam(addr);
+          this.beginCheckCam(addr, socket);
       }
     } else if (hasHeader(msg, ResponseMessageType.CAM_ID) || hasHeader(msg, ResponseMessageType.TURN_SERVER_CAM_ID)) {
-      this.onConnected({ host: rinfo.address, port: rinfo.port });
+      this.onConnected({ host: rinfo.address, port: rinfo.port }, socket);
     } else if (hasHeader(msg, ResponseMessageType.PONG)) {
       this.lastPongData = msg.length > 4 ? msg.subarray(4) : void 0;
       this.lastPongAt = Date.now();
       this.pathStaleTraced = false;
     } else if (hasHeader(msg, ResponseMessageType.PING)) {
-      this.send({ host: rinfo.address, port: rinfo.port }, RequestMessageType.PONG);
+      this.send({ host: rinfo.address, port: rinfo.port }, RequestMessageType.PONG, void 0, socket);
     } else if (hasHeader(msg, ResponseMessageType.ACK)) {
       this.onAck(msg);
     } else if (hasHeader(msg, ResponseMessageType.DATA)) {
@@ -15643,17 +15662,67 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       this.logger.debug(`[p2p] ${this.cfg.stationSn} UNHANDLED payload hex: ${msg.toString("hex")}`);
     }
   }
-  beginCheckCam(addr) {
+  beginCheckCam(addr, socket) {
     this.logger.debug(`[p2p] ${this.cfg.stationSn} beginCheckCam -> ${addr.host}:${addr.port} (+/-3)`);
     const payload = buildCheckCamPayload(this.cfg.p2pDid);
-    this.send(addr, RequestMessageType.CHECK_CAM, payload);
+    this.send(addr, RequestMessageType.CHECK_CAM, payload, socket);
     for (let p = addr.port - 3; p <= addr.port + 3; p++)
       if (p !== addr.port && p > 0)
-        this.send({ host: addr.host, port: p }, RequestMessageType.CHECK_CAM, payload);
+        this.send({ host: addr.host, port: p }, RequestMessageType.CHECK_CAM, payload, socket);
+  }
+  /** Bind additional UDP source ports before the first cloud lookup. */
+  async startPunchProbes() {
+    await Promise.all(Array.from({ length: PUNCH_PROBE_SOCKETS }, async () => {
+      const probe = dgram.createSocket("udp4");
+      probe.on("error", (error) => this.logger.warn("[p2p] lookup socket error", error.message));
+      probe.on("message", (msg, rinfo) => this.onMessage(msg, rinfo, probe));
+      this.probeSockets.push(probe);
+      await new Promise((resolve) => {
+        let settled = false;
+        const finish = (bound) => {
+          if (settled)
+            return;
+          settled = true;
+          probe.off("error", onError);
+          probe.off("close", onClose);
+          if (!bound) {
+            this.probeSockets = this.probeSockets.filter((socket) => socket !== probe);
+            try {
+              probe.close();
+            } catch {
+            }
+          }
+          resolve();
+        };
+        const onError = () => finish(false);
+        const onClose = () => finish(false);
+        probe.once("error", onError);
+        probe.once("close", onClose);
+        probe.bind(() => finish(true));
+      });
+    }));
   }
-  onConnected(addr) {
+  /** Close all lookup sockets except the one that completed the handshake. */
+  stopPunchProbes(winner) {
+    for (const probe of this.probeSockets) {
+      if (probe === winner)
+        continue;
+      probe.removeAllListeners("message");
+      probe.close();
+    }
+    this.probeSockets = [];
+  }
+  onConnected(addr, socket) {
     if (this.connected)
       return;
+    this.stopPunchProbes(socket);
+    if (this.socket !== socket) {
+      this.socket?.removeAllListeners();
+      this.socket?.close();
+      socket.removeAllListeners("error");
+      socket.on("error", (error) => this.emit("error", error));
+      this.socket = socket;
+    }
     this.connected = true;
     this.connectedAtMs = Date.now();
     this.connecting = false;
@@ -16540,11 +16609,11 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     }
     this.emit("data", frame);
   }
-  send(addr, type, payload) {
-    if (!this.socket)
+  send(addr, type, payload, socket = this.socket) {
+    if (!socket)
       return;
     const packet = frameMessage(type, payload);
-    this.socket.send(packet, addr.port, addr.host, (err) => {
+    socket.send(packet, addr.port, addr.host, (err) => {
       if (err)
         this.logger.warn(`[p2p] send err ${addr.host}:${addr.port}`, err.message);
     });
@@ -16553,6 +16622,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     if (this.closed)
       return;
     this.closed = true;
+    this.stopPunchProbes();
     this.connectionGeneration += 1;
     this.level2Key = void 0;
     this.level2Seq = 0;