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

package/dist/client/types.d.ts

@@ -377,8 +377,9 @@ export type EufyMegaEventMap = {
      * on `error`.
      *
      * The error carries the rate: `err.retryAfterMs` is how long the next session replacement is barred
-     * for, and `err.contended` says this session is being displaced by another client rather than expiring
-     * — which a re-login does not answer. A login made before that wait elapses extends it.
+     * for, and `err.contended` says the token was rejected again soon after being replaced, which is how
+     * displacement by another client looks and which a re-login does not answer. A login made before that
+     * wait elapses extends it.
      */
     sessionExpired: [err: SessionExpiredError];
     error: [err: Error];

package/dist/index.js

@@ -1102,8 +1102,9 @@ var SessionExpiredError = class extends Error {
   /**
    * Whether this rejection landed inside that bar — a token replaced recently and rejected again since.
    *
-   * It says the session is being DISPLACED rather than expiring: something else is signing in on this
-   * account, and replacing the token again only trades one login for another.
+   * That is the shape displacement by another client signed in on this account has, where replacing the
+   * token again only trades one login for another. It is not proof of one, since a cloud refusing to
+   * re-issue the session looks the same.
    */
   contended;
   constructor(message, opts = {}) {
@@ -1149,7 +1150,7 @@ var LoginStatus = {
 var REAUTH_HOLD_OFF_MS = 6e4;
 var REAUTH_HOLD_OFF_CAP_MS = 30 * 6e4;
 var REAUTH_STABLE_MS = 10 * 6e4;
-var CONTENDED_SESSION_HINT = "another client signed in on this account keeps displacing this session \u2014 the cloud holds about one session per account and device identity, so each login ends the other's; where the other client is another SDK install, give each its own openudid";
+var CONTENDED_SESSION_HINT = "the token was rejected again soon after it was last replaced; one possible cause is another client signed in with the same account and device identity, since the cloud holds about one session per pair and each login ends the other's (where that is another SDK install, give each its own openudid)";
 function tokenRejected(code, msg) {
   return code === EufyCloudErrorCode.SESSION_KICKED || /user_id is empty|invalid[^,]*\btoken\b|\btoken\b[^,]*(expired|error|not exist)|kicked|(?:\btoken\b|\bsession\b)[^,]*does not exist|unauthor/i.test(msg ?? "");
 }
@@ -1163,6 +1164,8 @@ var MegaHttpClient = class {
   sessionKey;
   /** Per-host ECDH session keys for non-mega gateways (e.g. eufylife) keyed by host. */
   sessionKeys = /* @__PURE__ */ new Map();
+  /** The in-flight key exchanges, by host and the token they carry — see {@link ensureSessionKey}. */
+  keyExchanges = /* @__PURE__ */ new Map();
   /**
    * The held credential. `userId` is the login reply's `ap_cloud_user_id` where it has one — the Anker
    * Passport cloud's id — while `accountUserId` is the eufy account's own `user_id`.
@@ -1384,6 +1387,20 @@ var MegaHttpClient = class {
         return cached2;
     }
     const host = isEufylife ? targetHost : this.bootstrapDomain ?? `app-openapi-${this.region}.eufy.com`;
+    const flight = `${host}
+${this.auth_?.authToken ?? ""}`;
+    const joining = this.keyExchanges.get(flight);
+    if (joining)
+      return joining;
+    const exchange = this.exchangeSessionKey(host, isEufylife).finally(() => {
+      if (this.keyExchanges.get(flight) === exchange)
+        this.keyExchanges.delete(flight);
+    });
+    this.keyExchanges.set(flight, exchange);
+    return exchange;
+  }
+  /** One key exchange against `host`, installed as that host's key. */
+  async exchangeSessionKey(host, isEufylife) {
     const kxPath = isEufylife ? "/v3/openapi/oauth/key/exchange" : "/openapi/oauth/key/exchange";
     const prep = prepareKeyExchange(isEufylife ? EUFYLIFE_LOCAL_KEY_HEX : void 0);
     const res = await this.httpPost(`https://${host}${kxPath}`, { client_public_key: prep.encryptedClientPublicKey }, {
@@ -1399,7 +1416,7 @@ var MegaHttpClient = class {
     }
     const entry = finishKeyExchange(prep, env.data.server_public_key);
     if (isEufylife)
-      this.sessionKeys.set(targetHost, entry);
+      this.sessionKeys.set(host, entry);
     else
       this.sessionKey = entry;
     return entry;
@@ -1470,9 +1487,10 @@ var MegaHttpClient = class {
     const identityError = authed && (last?.code === EufyCloudErrorCode.IDENTITY_KEY_STALE || /get identity error|identity error/i.test(last?.msg ?? ""));
     if (identityError && !retry.identity && this.auth_) {
       this.logger.debug("[mega] identity error \u2192 re-exchanging session key and retrying");
-      if (host.includes(".eufylife.com"))
-        this.sessionKeys.delete(host);
-      else
+      if (host.includes(".eufylife.com")) {
+        if (this.sessionKeys.get(host) === entry)
+          this.sessionKeys.delete(host);
+      } else if (this.sessionKey === entry)
         this.sessionKey = void 0;
       try {
         await this.ensureSessionKey(host);
@@ -1832,14 +1850,14 @@ var MegaHttpClient = class {
    * like the same device — and the cloud keeps one session per device. Each finds its token rejected, replaces
    * it, and evicts the other: an unbounded login war, silent, and repeated logins are exactly what makes an
    * account start demanding captchas. The first replacement is immediate, because a token displaced once is
-   * the ordinary case; a second one soon after is evidence of contention rather than expiry, so the wait grows
-   * and a caller is told the honest reason instead of being served a fight.
+   * the ordinary case; a second one soon after has the shape of contention rather than expiry, so the wait grows
+   * and a caller is told what was seen instead of being served a fight.
    */
   recoveryDue() {
     const remaining = this.holdOffRemainingMs();
     if (remaining === 0)
       return true;
-    this.logger.warn(`[mega] token rejected ${Math.round((Date.now() - this.lastRecoveryAt) / 1e3)}s after the last replacement \u2014 holding off ${Math.round(remaining / 1e3)}s more. ${CONTENDED_SESSION_HINT}`);
+    this.logger.warn(`[mega] holding off ${Math.round(remaining / 1e3)}s more before replacing the token again (last replaced ${Math.round((Date.now() - this.lastRecoveryAt) / 1e3)}s ago): ${CONTENDED_SESSION_HINT}`);
     return false;
   }
   /**
@@ -15141,6 +15159,8 @@ var LIVE_START_ACK_DEADLINE_MS = 3e3;
 var SEQUENCE_LOOKBACK = 32768;
 var STALE_RETRANSMIT_DEPTH = 1024;
 var PUNCH_PROBE_SOCKETS = 7;
+var REORDER_WAIT_MS = 250;
+var REORDER_MAX_DATAGRAMS = 128;
 var MAX_TRACED_DATAGRAM_GAPS = 8;
 var CMD_SET_PAYLOAD = 1350;
 var CMD_NOTIFY_PAYLOAD = 1351;
@@ -15210,9 +15230,10 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   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
-   * mid-frame and drop the (now unrecoverable) partial frame instead of splicing wrong bytes. */
+  /** Last delivered datagram sequence number per data type. */
   lastSeqByType = /* @__PURE__ */ new Map();
+  /** Held datagrams and their active gap timer, grouped by data type. */
+  reorderByType = /* @__PURE__ */ new Map();
   tracedDatagramGaps = 0;
   level1Key;
   /** Negotiated 32-byte level-2/gateway key (AES-256-GCM). Set via setLevel2Key once known. */
@@ -16467,8 +16488,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Acknowledge and reassemble one DATA datagram, sequenced independently per data type.
    *
    * The device numbers each data type's datagrams in its own 16-bit space and repeats what it thinks was
-   * lost, so a datagram that does not advance the sequence — a duplicate, or one already superseded — is a
-   * retransmission of something already reassembled: it is acknowledged, then ignored. Distance is measured
+   * lost. A repeat of something already delivered is acknowledged, then ignored. Distance is measured
    * modulo the sequence space and read as backwards beyond {@link SEQUENCE_LOOKBACK}, which is what lets the
    * numbering wrap without the next datagram looking like a jump of nearly a full space.
    *
@@ -16478,9 +16498,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * numbering and the half-assembled frame goes — because ignoring it would freeze the mark, and every
    * datagram of the new numbering would then be read as behind it too, for as long as it took to climb back.
    *
-   * Only a forward gap means a datagram is genuinely missing. A logical frame's payload spans datagrams that
-   * carry no header of their own, so the bytes cannot be reassembled around the hole: whatever was pending
-   * for that data type is discarded, and the frame is rebuilt from the next header.
+   * A forward gap means a datagram has not arrived YET, which is not the same as lost. The device repeats
+   * unacknowledged datagrams, so successors are held for a bounded wait and delivered strictly in sequence
+   * if the missing one arrives. A logical frame's payload spans datagrams that carry no header of their
+   * own, so reassembling around a hole is impossible; waiting for it is what keeps the frame whole.
+   *
+   * Only once {@link REORDER_WAIT_MS} passes, or {@link REORDER_MAX_DATAGRAMS} pile up, is the datagram
+   * treated as lost: a pending frame is discarded and delivery resumes from the earliest held datagram.
    */
   onData(msg, addr) {
     const dataTypeBuffer = msg.subarray(4, 6);
@@ -16491,18 +16515,98 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     const advance = prevSeq === void 0 ? 1 : seqNo - prevSeq & 65535;
     if (advance === 0)
       return;
-    const restarted = advance > SEQUENCE_LOOKBACK && 65536 - advance > STALE_RETRANSMIT_DEPTH;
-    if (advance > SEQUENCE_LOOKBACK && !restarted)
-      return;
-    this.lastSeqByType.set(dataType, seqNo);
-    if ((advance > 1 || restarted) && this.pendingByDataType.has(dataType)) {
-      if (this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS) {
-        this.trace({ phase: restarted ? "sequence-restart" : "datagram-gap", dataType });
-      }
+    if (advance > SEQUENCE_LOOKBACK) {
+      if (65536 - advance <= STALE_RETRANSMIT_DEPTH)
+        return;
+      if (this.pendingByDataType.has(dataType) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
+        this.trace({ phase: "sequence-restart", dataType });
+      this.clearReorderTimer(dataType);
+      this.reorderByType.delete(dataType);
       this.pendingByDataType.delete(dataType);
+      this.lastSeqByType.set(dataType, seqNo);
+      this.reassemble(dataType, msg.subarray(8));
+      return;
+    }
+    if (advance === 1) {
+      this.lastSeqByType.set(dataType, seqNo);
+      this.reassemble(dataType, msg.subarray(8));
+      this.drainReorder(dataType);
+      return;
+    }
+    this.holdForRetransmit(dataType, seqNo, msg.subarray(8));
+  }
+  /** Hold a datagram that arrived past a hole, and arm the wait for the missing one to be repeated. */
+  holdForRetransmit(dataType, seqNo, body) {
+    let reorder = this.reorderByType.get(dataType);
+    if (!reorder) {
+      reorder = { held: /* @__PURE__ */ new Map() };
+      this.reorderByType.set(dataType, reorder);
+    }
+    if (!reorder.held.has(seqNo))
+      reorder.held.set(seqNo, body);
+    if (reorder.held.size > REORDER_MAX_DATAGRAMS) {
+      this.abandonHole(dataType);
+      return;
     }
+    this.armReorderTimer(dataType);
+  }
+  /** Start a full wait for the current hole, leaving an existing wait undisturbed. */
+  armReorderTimer(dataType) {
+    const reorder = this.reorderByType.get(dataType);
+    if (!reorder?.held.size || reorder.timer)
+      return;
+    const timer = setTimeout(() => {
+      reorder.timer = void 0;
+      this.abandonHole(dataType);
+    }, REORDER_WAIT_MS);
+    timer.unref?.();
+    reorder.timer = timer;
+  }
+  /** Deliver held datagrams that now follow directly on from the last one delivered. */
+  drainReorder(dataType) {
+    const reorder = this.reorderByType.get(dataType);
+    if (!reorder?.held.size)
+      return;
+    this.clearReorderTimer(dataType);
+    for (; ; ) {
+      const next = this.lastSeqByType.get(dataType) + 1 & 65535;
+      const body = reorder.held.get(next);
+      if (body === void 0)
+        break;
+      reorder.held.delete(next);
+      this.lastSeqByType.set(dataType, next);
+      this.reassemble(dataType, body);
+    }
+    if (reorder.held.size)
+      this.armReorderTimer(dataType);
+    else
+      this.reorderByType.delete(dataType);
+  }
+  /**
+   * The missing datagram was not repeated in time: report the gap, drop the frame it belonged to, and
+   * resume from the earliest datagram still held so the stream keeps moving.
+   */
+  abandonHole(dataType) {
+    const held = this.reorderByType.get(dataType).held;
+    if (this.pendingByDataType.has(dataType) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
+      this.trace({ phase: "datagram-gap", dataType });
+    this.pendingByDataType.delete(dataType);
+    const last = this.lastSeqByType.get(dataType);
+    const earliest = [...held.keys()].sort((a, b) => (a - last & 65535) - (b - last & 65535))[0];
+    this.lastSeqByType.set(dataType, earliest - 1 & 65535);
+    this.drainReorder(dataType);
+  }
+  clearReorderTimer(dataType) {
+    const reorder = this.reorderByType.get(dataType);
+    if (!reorder?.timer)
+      return;
+    clearTimeout(reorder.timer);
+    reorder.timer = void 0;
+  }
+  /** Reassemble one in-sequence datagram body into logical frames. */
+  reassemble(dataType, datagramBody) {
     const pending = this.pendingByDataType.get(dataType);
-    let body = pending ? Buffer.concat([pending.buf, msg.subarray(8)]) : msg.subarray(8);
+    let body = pending ? Buffer.concat([pending.buf, datagramBody]) : datagramBody;
     const carryHeader = pending?.header;
     this.pendingByDataType.delete(dataType);
     if (carryHeader) {
@@ -16533,6 +16637,9 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * completed either.
    */
   resetInboundSequencing() {
+    for (const dataType of this.reorderByType.keys())
+      this.clearReorderTimer(dataType);
+    this.reorderByType.clear();
     this.lastSeqByType.clear();
     this.pendingByDataType.clear();
     this.tracedDatagramGaps = 0;