@mega-yfue/eufy-sdk 0.6.0-beta.31 → 0.6.0-beta.32

package/dist/index.js

@@ -1609,11 +1609,17 @@ var CONTENDED_SESSION_HINT = "the token was rejected again soon after it was las
 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 ?? "");
 }
+function shardOfDomain(domain) {
+  const m = /-([a-z]{2})(?:[.-]|$)/i.exec(domain);
+  return m ? `${m[1].toLowerCase()}-pr` : void 0;
+}
 var MegaHttpClient = class {
   cfg;
   region;
   /** The host `estimate_domain` answered, persisted with the session. */
   estimatedDomain = "";
+  /** The in-flight (then settled, so cached) RTC-sign shard request from {@link portalShard}. */
+  portalShardInFlight;
   bootstrapDomain;
   sessionKey;
   /** Per-host ECDH session keys for non-mega gateways (e.g. eufylife) keyed by host. */
@@ -1730,13 +1736,36 @@ var MegaHttpClient = class {
     return this.region;
   }
   /**
-   * The shard the RTC signalling signs on: the regional prefix of the estimated domain
-   * (`…-ie-…`/`…-ie.` → `ie-pr`), else {@link regionShard}. The eu/us classification cannot name shards
-   * like `ie-pr`, whose accounts need the IE sign host and cluster.
+   * The shard the estimated domain names (`…-ie-…`/`…-ie.` → `ie-pr`), else {@link regionShard}. The
+   * eu/us classification cannot name shards like `ie-pr`.
    */
   get rtcShard() {
-    const m = /-([a-z]{2})(?:[.-]|$)/i.exec(this.estimatedDomain);
-    return m ? `${m[1].toLowerCase()}-pr` : this.region;
+    return shardOfDomain(this.estimatedDomain) ?? this.region;
+  }
+  /**
+   * The shard the RTC signalling signs on, from `estimate_domain` asked with the portal's WEB identity
+   * (`Model-Type: WEB`, `App-Name: eufy_mega`) — the identity the sign itself is sent with, which can name
+   * a different shard than the PHONE identity does for one account. The in-flight request is shared by
+   * concurrent first callers, and once it settles to a shard the resolved promise is the cache; a call
+   * that fails or names no shard answers {@link rtcShard}, clears the field and is asked again next time.
+   */
+  async portalShard() {
+    return this.portalShardInFlight ??= this.fetchPortalShard();
+  }
+  async fetchPortalShard() {
+    try {
+      const res = await this.estimateDomainRequest({ "Model-Type": "WEB", "App-Name": "eufy_mega" });
+      const domain = res.data?.data?.domain;
+      const shard = typeof domain === "string" ? shardOfDomain(domain) : void 0;
+      if (shard) {
+        this.logger.debug("[mega] portal shard:", shard);
+        return shard;
+      }
+    } catch (e) {
+      this.logger.debug("[mega] portal estimate_domain failed:", e instanceof Error ? e.message : String(e));
+    }
+    this.portalShardInFlight = void 0;
+    return this.rtcShard;
   }
   /**
    * The credentials the RTC signalling needs; `undefined` while logged out. The sign is refused
@@ -1833,13 +1862,13 @@ var MegaHttpClient = class {
     });
     return { status: res.status, data: parseMaybeJson(await res.text()) };
   }
+  /** POST `estimate_domain` with the given identity headers. */
+  estimateDomainRequest(headers) {
+    return this.httpPost(`https://mega-${this.region}.eufy.com/passport/estimate_domain`, { ab: this.cfg.countryCode.toLowerCase(), mode: 1 }, { ...headers, "content-type": "application/json" });
+  }
   /** Step 1: discover the account's region shard (and the bootstrap host). */
   async estimateDomain() {
-    const url = `https://mega-${this.region}.eufy.com/passport/estimate_domain`;
-    const res = await this.httpPost(url, { ab: this.cfg.countryCode.toLowerCase(), mode: 1 }, {
-      ...this.baseHeaders(),
-      "content-type": "application/json"
-    });
+    const res = await this.estimateDomainRequest(this.baseHeaders());
     this.logger.debug("[mega] estimate_domain raw:", JSON.stringify(res.data).slice(0, 400));
     const env = res.data;
     const d = env?.data ?? {};
@@ -25727,6 +25756,8 @@ var RtcCommandRouter = class {
   warm = /* @__PURE__ */ new Map();
   callSources = /* @__PURE__ */ new Map();
   lastTransaction = 0;
+  /** The latest shard each `call` source resolved, read by its `makeStream` (see {@link callMediaProviderFor}). */
+  callShards = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -25853,7 +25884,13 @@ var RtcCommandRouter = class {
       views
     };
   }
-  /** Share a dedicated-call source and its consumer operations under one route key. */
+  /**
+   * Share a dedicated-call source and its consumer operations under one route key.
+   *
+   * `SharedLiveSource` calls `makeStream` synchronously, so the shard cannot be awaited inside it. Each
+   * async entry point resolves the shard and records it in {@link callShards} before touching the source;
+   * `makeStream` reads the latest recorded value.
+   */
   callMediaProviderFor(route, key, makeStream, recordError, warmTimeoutMs) {
     const sourceFor = (opts = {}) => {
       opts.signal?.throwIfAborted();
@@ -25867,7 +25904,7 @@ var RtcCommandRouter = class {
             if (!identity)
               throw new Error(`rtc: not logged in, cannot call ${route.stationSn}`);
             const accountId = route.adminUserId || identity.userId;
-            return makeStream(this.newSession(route, accountId, identity), accountId, view);
+            return makeStream(this.newSession(route, accountId, identity, this.callShards.get(key)), accountId, view);
           },
           label: sourceKey,
           logger: this.deps.logger,
@@ -25879,14 +25916,26 @@ var RtcCommandRouter = class {
       }
       return source;
     };
+    const resolveShard = async () => {
+      this.callShards.set(key, await this.deps.shard(route));
+    };
     return {
-      live: async (opts) => attachUnlessAborted(sourceFor(opts), opts?.signal),
-      openReadable: async (opts) => openReadableFromConsumer(attachUnlessAborted(sourceFor(opts), opts?.signal), opts),
-      snapshotLive: async (opts) => captureSnapshotFromShared(sourceFor(opts), {
-        ...opts,
-        logger: this.deps.logger,
-        ffmpegPath: this.deps.ffmpegPath
-      }),
+      live: async (opts) => {
+        await resolveShard();
+        return attachUnlessAborted(sourceFor(opts), opts?.signal);
+      },
+      openReadable: async (opts) => {
+        await resolveShard();
+        return openReadableFromConsumer(attachUnlessAborted(sourceFor(opts), opts?.signal), opts);
+      },
+      snapshotLive: async (opts) => {
+        await resolveShard();
+        return captureSnapshotFromShared(sourceFor(opts), {
+          ...opts,
+          logger: this.deps.logger,
+          ffmpegPath: this.deps.ffmpegPath
+        });
+      },
       record: async () => {
         throw new Error(recordError);
       }
@@ -25901,6 +25950,7 @@ var RtcCommandRouter = class {
       this.callSources.delete(sn);
       src.dispose();
     }
+    this.callShards.clear();
     for (const [sn, live] of this.lives) {
       this.lives.delete(sn);
       live.source.dispose();
@@ -26094,31 +26144,50 @@ var RtcCommandRouter = class {
       }
     });
   }
-  newSession(route, adminUserId, identity) {
+  newSession(route, adminUserId, identity, shard) {
     return (this.deps.createSession ?? ((o) => new RtcSession(o)))({
       authToken: identity.authToken,
       gtoken: identity.gtoken,
       stationSn: route.stationSn,
       adminUserId,
-      shard: this.deps.shard(),
+      shard,
       country: this.deps.country ?? "US",
       logger: this.deps.logger,
       signalingMode: route.signalingMode,
       peer: { logger: this.deps.logger, iceTransportPolicy: route.iceTransportPolicy, mediaTrack: route.mediaTrack }
     });
   }
+  /** A connected session for `sn` to reuse, or undefined (dropping a dead one). */
+  async reusable(sn) {
+    const st = this.sessions.get(sn);
+    if (!st)
+      return void 0;
+    await st.ready;
+    if (st.session.isConnected) {
+      this.touch(sn, st);
+      return st;
+    }
+    this.drop(sn, st);
+    return void 0;
+  }
+  /**
+   * Get or open the station's session. A connected session is reused before the shard is awaited, so a
+   * command on an already-connected station never waits on the unauthenticated `estimate_domain` round
+   * trip — only the create path awaits it. After the await the map is re-checked, with no `await` between
+   * the lookup and `this.sessions.set`, so concurrent creators still share one session.
+   */
   async stationSession(route, adminUserId, identity) {
     const sn = route.stationSn;
-    const existing = this.sessions.get(sn);
-    if (existing) {
-      await existing.ready;
-      if (existing.session.isConnected) {
-        this.touch(sn, existing);
-        return existing;
-      }
-      this.drop(sn, existing);
-    }
-    const session = this.newSession(route, adminUserId, identity);
+    const reused = await this.reusable(sn);
+    if (reused)
+      return reused;
+    const shard = await this.deps.shard(route);
+    if (this.sessions.has(sn)) {
+      const again = await this.reusable(sn);
+      if (again)
+        return again;
+    }
+    const session = this.newSession(route, adminUserId, identity, shard);
     const ready = this.bringUp(sn, session);
     const st = { session, seg: new SegmentCounter(), ready, queue: Promise.resolve(), leases: 0 };
     session.on("error", (e) => this.deps.onError?.(e));
@@ -29768,7 +29837,7 @@ var EufyMega = class _EufyMega extends EventEmitter14 {
     });
     this.rtc = new RtcCommandRouter({
       identity: () => this.mega.rtcIdentity(),
-      shard: () => this.mega.rtcShard,
+      shard: (route) => route.mediaTrack ? this.mega.rtcShard : this.mega.portalShard(),
       country: opts.countryCode,
       logger: opts.logger,
       ffmpegPath: opts.ffmpegPath,