@ezychat/wa 0.1.69 → 0.1.70

package/dist/baileys/adapter.js

@@ -5,6 +5,7 @@ import { WaUnavailableError, } from '../types.js';
 import { createAuthStore } from './auth-store.js';
 import { backoffMs, classifyDisconnect } from './disconnect.js';
 import { Lru } from './lru.js';
+import { createWaVersionSource } from './wa-version.js';
 import { jidType, mapStoredReactions, mapWAMessage, mapWAReaction, toMs } from './mapping.js';
 import { quotedForChat, quotedFromRef } from './quoted.js';
 import { mapWAProtocol } from './protocol.js';
@@ -16,6 +17,10 @@ const RAW_CACHE_MAX = 2000;
 /** How long an edit or delete this adapter sent waits for WhatsApp's echo of it. */
 const OWN_CHANGE_TTL_MS = 60_000;
 const DAY_MS = 86_400_000;
+/** One per process: every inbox and reconnect shares the looked-up WhatsApp Web version. */
+const waVersion = createWaVersionSource({
+    fetchLatest: () => fetchLatestBaileysVersion(),
+});
 /** Boom status codes Baileys uses when the socket is closed / lost / replaced / unavailable. */
 const CONNECTION_STATUS_CODES = new Set([408, 428, 440, 503]);
 /** True when a send error means "the connection went away" (retry later) rather than a real rejection. */
@@ -239,14 +244,12 @@ export class BaileysAdapter extends EventEmitter {
     async open() {
         this.setStatus({ state: 'connecting', qr: null });
         const { state, saveCreds } = await this.auth.load();
-        let version;
-        try {
-            const latest = await fetchLatestBaileysVersion();
-            version = latest.version;
-        }
-        catch (err) {
-            this.logger.warn({ err }, 'could not fetch latest WA version; using bundled default');
-        }
+        // Never wait for the GitHub lookup: connect with the version we have, refresh it for next time.
+        const version = waVersion.current();
+        void waVersion.refresh().then(({ error }) => {
+            if (error)
+                this.logger.warn({ err: error }, 'could not fetch latest WA version');
+        });
         if (this.stopped)
             return; // disconnect() was called while loading
         const blog = this.logger.child({ module: 'baileys' });

package/dist/baileys/wa-version.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The WhatsApp Web version to announce. WhatsApp refuses clients whose version is too old, so Baileys
+ * suggests looking up the newest one from its GitHub copy on every connect. That lookup has no
+ * timeout, and awaiting it before the socket held every connect (and every new QR) at "connecting"
+ * while GitHub was slow or blocked. A connect never waits for it now: it uses the last version
+ * looked up (or Baileys' bundled one) at once, and the lookup refreshes in the background, bounded
+ * by `timeoutMs` and cached, so a connect WhatsApp refused for an old version retries with the new one.
+ */
+export type WaVersion = [number, number, number];
+export interface WaVersionSourceOptions {
+    fetchLatest: () => Promise<{
+        version: WaVersion;
+    }>;
+    timeoutMs?: number;
+    /** How long a fetched version is reused before the next lookup. */
+    ttlMs?: number;
+    /** How long to skip the lookup after a failure or timeout. */
+    failureTtlMs?: number;
+    now?: () => number;
+}
+export declare const WA_VERSION_TIMEOUT_MS = 10000;
+export interface WaVersionRefresh {
+    version: WaVersion | undefined;
+    /** Set when this refresh tried the lookup and it failed or timed out. */
+    error?: unknown;
+}
+export interface WaVersionSource {
+    /** The version to connect with now: the last one looked up, else undefined (Baileys' bundled one). */
+    current(): WaVersion | undefined;
+    /** Looks the version up unless a recent result is cached; never rejects, one lookup at a time. */
+    refresh(): Promise<WaVersionRefresh>;
+}
+export declare function createWaVersionSource(opts: WaVersionSourceOptions): WaVersionSource;

package/dist/baileys/wa-version.js

@@ -0,0 +1,44 @@
+export const WA_VERSION_TIMEOUT_MS = 10_000;
+const WA_VERSION_TTL_MS = 6 * 60 * 60_000;
+const WA_VERSION_FAILURE_TTL_MS = 10 * 60_000;
+export function createWaVersionSource(opts) {
+    const timeoutMs = opts.timeoutMs ?? WA_VERSION_TIMEOUT_MS;
+    const ttlMs = opts.ttlMs ?? WA_VERSION_TTL_MS;
+    const failureTtlMs = opts.failureTtlMs ?? WA_VERSION_FAILURE_TTL_MS;
+    const now = opts.now ?? Date.now;
+    let version;
+    let nextLookupAt = 0;
+    let inflight = null;
+    const lookup = async () => {
+        let timer;
+        try {
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`WA version lookup timed out after ${timeoutMs} ms`)), timeoutMs);
+                timer.unref?.();
+            });
+            ({ version } = await Promise.race([opts.fetchLatest(), timeout]));
+            nextLookupAt = now() + ttlMs;
+            return { version };
+        }
+        catch (error) {
+            nextLookupAt = now() + failureTtlMs;
+            return { version, error };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    return {
+        current: () => version,
+        refresh() {
+            if (inflight)
+                return inflight;
+            if (now() < nextLookupAt)
+                return Promise.resolve({ version });
+            inflight = lookup().finally(() => {
+                inflight = null;
+            });
+            return inflight;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezychat/wa",
-  "version": "0.1.69",
+  "version": "0.1.70",
   "type": "module",
   "description": "EzyChat core: WhatsApp adapter interface, Baileys adapter and fake adapter.",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ezychat/shared": "0.1.69",
+    "@ezychat/shared": "0.1.70",
     "baileys": "^7.0.0-rc14",
     "pino": "^10.4.0",
     "qrcode": "^1.5.4"