zapo-js 0.2.0 → 1.0.0

package/dist/esm/client/connection/WaConnectionManager.js

@@ -2,7 +2,6 @@ import { WaComms } from '../../transport/WaComms.js';
 import { toError } from '../../util/primitives.js';
 export class WaConnectionManager {
     constructor(options) {
-        this.lastConnectWasNewLogin = false;
         this.logger = options.logger;
         this.options = options.options;
         this.authClient = options.authClient;
@@ -11,11 +10,13 @@ export class WaConnectionManager {
         this.nodeTransport = options.nodeTransport;
         this.getPassiveTasks = options.getPassiveTasks;
         this.clearStoredCredentialsCallback = options.clearStoredCredentials;
+        this.onPostPairReconnected = options.onPostPairReconnected;
         this.comms = null;
         this.clockSkewMs = null;
         this.mediaConnCache = null;
         this.connectPromise = null;
         this.pairingReconnectPromise = null;
+        this.pairingReconnectTimeout = null;
         this.frameHandler = null;
         this.pendingComms = null;
         this.lifecycleGeneration = 0;
@@ -41,13 +42,18 @@ export class WaConnectionManager {
     }
     scheduleReconnectAfterPairing() {
         this.logger.debug('wa client scheduling reconnect after pairing');
-        setTimeout(() => {
+        if (this.pairingReconnectTimeout) {
+            clearTimeout(this.pairingReconnectTimeout);
+        }
+        this.pairingReconnectTimeout = setTimeout(() => {
+            this.pairingReconnectTimeout = null;
             void this.reconnectAsRegisteredAfterPairing().catch((error) => {
                 if (this.isLifecycleSupersededError(error)) {
                     this.logger.trace('pairing reconnect canceled by newer lifecycle');
                     return;
                 }
                 this.logger.warn('failed to reconnect after pairing', {
+                    meJid: this.authClient.getCurrentCredentials()?.meJid,
                     message: toError(error).message
                 });
             });
@@ -66,9 +72,6 @@ export class WaConnectionManager {
     isConnected() {
         return !!(this.comms && this.comms.getCommsState().connected);
     }
-    wasNewLogin() {
-        return this.lastConnectWasNewLogin;
-    }
     getComms() {
         return this.comms;
     }
@@ -90,15 +93,24 @@ export class WaConnectionManager {
             clockSkewMs: this.clockSkewMs
         });
     }
+    setClockSkewMs(clockSkewMs, source) {
+        if (!Number.isFinite(clockSkewMs)) {
+            return;
+        }
+        const previous = this.clockSkewMs;
+        this.clockSkewMs = clockSkewMs;
+        if (previous === null || Math.abs(previous - clockSkewMs) >= 1000) {
+            this.logger.debug('clock skew updated', { source, clockSkewMs, previous });
+        }
+    }
     async connectInternal(frameHandler, lifecycleGeneration) {
         this.assertLifecycleCurrent(lifecycleGeneration, 'connect');
         if (this.comms || this.pendingComms) {
             this.logger.trace('wa client connect skipped: comms already created');
             return;
         }
-        this.logger.info('wa client connect start');
+        this.logger.debug('wa client connect start');
         let credentials = await this.authClient.loadOrCreateCredentials();
-        this.lastConnectWasNewLogin = !credentials.meJid;
         this.assertLifecycleCurrent(lifecycleGeneration, 'connect');
         try {
             await this.startCommsWithCredentials(credentials, frameHandler, lifecycleGeneration);
@@ -166,12 +178,17 @@ export class WaConnectionManager {
         this.assertLifecycleCurrent(lifecycleGeneration, 'pairing reconnect');
         await this.startCommsWithCredentials(credentials, frameHandler, lifecycleGeneration);
         this.assertLifecycleCurrent(lifecycleGeneration, 'pairing reconnect');
+        this.onPostPairReconnected();
     }
     async disconnectInternal(lifecycleGeneration) {
         if (!this.isLifecycleCurrent(lifecycleGeneration)) {
             return;
         }
-        this.logger.info('wa client disconnect start');
+        this.logger.debug('wa client disconnect start');
+        if (this.pairingReconnectTimeout) {
+            clearTimeout(this.pairingReconnectTimeout);
+            this.pairingReconnectTimeout = null;
+        }
         this.keepAlive.stop();
         this.nodeOrchestrator.clearPending(new Error('client disconnected'));
         this.clockSkewMs = null;
@@ -192,7 +209,7 @@ export class WaConnectionManager {
                 : Promise.resolve()
         ]);
         if (this.isLifecycleCurrent(lifecycleGeneration)) {
-            this.logger.info('wa client disconnected');
+            this.logger.debug('wa client disconnected');
         }
     }
     async startCommsWithCredentials(credentials, frameHandler, lifecycleGeneration) {
@@ -200,7 +217,10 @@ export class WaConnectionManager {
         this.logger.debug('starting comms with credentials', {
             registered: credentials.meJid !== null && credentials.meJid !== undefined
         });
-        const commsConfig = this.authClient.buildCommsConfig(this.options);
+        const commsConfig = await this.authClient.buildCommsConfig(this.options, {
+            noiseTrustedRootCa: this.options.testHooks?.noiseRootCa,
+            disableNoiseCertificateChainVerification: this.options.dangerous?.disableNoiseCertificateChainVerification
+        });
         const comms = new WaComms(commsConfig, this.logger);
         this.pendingComms = comms;
         this.mediaConnCache = null;
@@ -214,7 +234,7 @@ export class WaConnectionManager {
             this.comms = comms;
             this.pendingComms = null;
             this.nodeTransport.bindComms(comms);
-            this.logger.info('comms connected');
+            this.logger.debug('comms connected');
             comms.startHandlingRequests();
             if (credentials.meJid) {
                 this.keepAlive.start();

package/dist/esm/client/coordinators/WaAbPropsCoordinator.js

@@ -0,0 +1,136 @@
+import { parseAbPropsIqResult } from '../events/abprops.js';
+import { AB_PROP_CONFIGS, resolveAbPropNameByCode, WA_ABPROPS_REFRESH_BOUNDS } from '../../protocol/abprops.js';
+import { WA_DEFAULTS } from '../../protocol/constants.js';
+import { buildGetAbPropsIq } from '../../transport/node/builders/abprops.js';
+import { parseOptionalInt, toError } from '../../util/primitives.js';
+export class WaAbPropsCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.runtime = options.runtime;
+        this.cache = new Map();
+        this.syncState = { hash: null, abKey: null, refreshId: null };
+        this.syncPromise = null;
+        this.syncEpoch = 0;
+        this.pendingSync = false;
+    }
+    getConfigValue(name) {
+        const cached = this.cache.get(name);
+        if (cached !== undefined) {
+            return cached;
+        }
+        return AB_PROP_CONFIGS[name].defaultValue;
+    }
+    sync() {
+        if (this.syncPromise) {
+            this.pendingSync = true;
+            return;
+        }
+        this.startSync();
+    }
+    reset() {
+        this.cache.clear();
+        this.syncState.hash = null;
+        this.syncState.abKey = null;
+        this.syncState.refreshId = null;
+        this.syncPromise = null;
+        this.pendingSync = false;
+        this.syncEpoch += 1;
+    }
+    startSync() {
+        const epoch = this.syncEpoch;
+        this.pendingSync = false;
+        this.syncPromise = this.executeSyncWithRetry(epoch)
+            .catch((error) => {
+            this.logger.warn('ab props sync failed', {
+                message: toError(error).message
+            });
+        })
+            .finally(() => {
+            if (this.syncEpoch !== epoch) {
+                return;
+            }
+            this.syncPromise = null;
+            if (this.pendingSync) {
+                this.startSync();
+            }
+        });
+    }
+    async executeSyncWithRetry(epoch) {
+        const maxRetries = 3;
+        for (let attempt = 0; attempt < maxRetries; attempt += 1) {
+            if (this.syncEpoch !== epoch) {
+                return;
+            }
+            try {
+                await this.executeSync(epoch);
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                this.logger.debug('ab props sync retrying', {
+                    attempt: attempt + 1,
+                    message: toError(error).message
+                });
+            }
+        }
+    }
+    async executeSync(epoch) {
+        const iqNode = buildGetAbPropsIq({
+            hash: this.syncState.hash,
+            refreshId: this.syncState.refreshId
+        });
+        const response = await this.runtime.queryWithContext('abprops.sync', iqNode, WA_DEFAULTS.IQ_TIMEOUT_MS);
+        if (this.syncEpoch !== epoch) {
+            return;
+        }
+        const result = parseAbPropsIqResult(response);
+        if (result.abKey !== null) {
+            this.syncState.abKey = result.abKey;
+        }
+        if (result.hash !== null) {
+            this.syncState.hash = result.hash;
+        }
+        if (result.refreshId !== null) {
+            this.syncState.refreshId = result.refreshId;
+        }
+        if (!result.isDeltaUpdate) {
+            this.cache.clear();
+        }
+        let applied = 0;
+        for (let i = 0; i < result.props.length; i += 1) {
+            const entry = result.props[i];
+            const name = resolveAbPropNameByCode(entry.configCode);
+            if (!name) {
+                continue;
+            }
+            const config = AB_PROP_CONFIGS[name];
+            const parsed = parseConfigValue(entry.configValue, config.type, config.defaultValue);
+            this.cache.set(name, parsed);
+            applied += 1;
+        }
+        this.logger.info('ab props synced', {
+            received: result.props.length,
+            applied,
+            isDelta: result.isDeltaUpdate,
+            abKey: result.abKey,
+            refresh: result.refresh !== null ? clampRefresh(result.refresh) : null
+        });
+    }
+}
+function parseConfigValue(value, type, defaultValue) {
+    if (value === null) {
+        return defaultValue;
+    }
+    if (type === 'bool') {
+        return value === '1' || value === 'true' || value === 'True';
+    }
+    if (type === 'int') {
+        return parseOptionalInt(value) ?? defaultValue;
+    }
+    return value;
+}
+function clampRefresh(seconds) {
+    return Math.max(WA_ABPROPS_REFRESH_BOUNDS.MIN_S, Math.min(WA_ABPROPS_REFRESH_BOUNDS.MAX_S, seconds));
+}