zapo-js 0.1.1 → 0.1.2

package/dist/esm/client/WaClient.js

@@ -6,11 +6,10 @@ import { persistIncomingMailboxEntities } from './mailbox.js';
 import { buildWaClientDependencies, resolveWaClientBase } from './WaClientFactory.js';
 import { ConsoleLogger } from '../infra/log/ConsoleLogger.js';
 import { proto } from '../proto.js';
-import { WA_APP_STATE_COLLECTION_STATES, WA_DEFAULTS, WA_MESSAGE_TAGS } from '../protocol/constants.js';
-import { normalizeDeviceJid, toUserJid } from '../protocol/jid.js';
+import { WA_APP_STATE_COLLECTION_STATES, WA_DEFAULTS } from '../protocol/constants.js';
+import { normalizeDeviceJid, parsePhoneJid, toUserJid } from '../protocol/jid.js';
 import { queryWithContext as queryNodeWithContext } from '../transport/node/query.js';
-import { WaComms } from '../transport/WaComms.js';
-import { decodeProtoBytes } from '../util/base64.js';
+import { decodeProtoBytes } from '../util/bytes.js';
 import { bytesToHex } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const SYNC_RELATED_PROTOCOL_TYPES = new Set([
@@ -24,15 +23,7 @@ const WA_APP_STATE_KEY_SHARE_MAX_RETRIES = 2;
 export class WaClient extends EventEmitter {
     constructor(options, logger = new ConsoleLogger('info')) {
         super();
-        this.clockSkewMs = null;
-        this.mediaConnCache = null;
-        this.comms = null;
-        this.pairingReconnectPromise = null;
         this.connectPromise = null;
-        this.danglingReceipts = [];
-        this.appStateKeyShareWaiters = new Set();
-        this.appStateKeyShareVersion = 0;
-        this.appStateBootstrapKeyShareWaitDone = false;
         const base = resolveWaClientBase(options, logger);
         this.options = base.options;
         this.logger = base.logger;
@@ -45,31 +36,20 @@ export class WaClient extends EventEmitter {
         this.signalStore = base.sessionStore.signal;
         this.senderKeyStore = base.sessionStore.senderKey;
         this.threadStore = base.sessionStore.threads;
-        const host = {
-            sendNode: (node) => this.sendNode(node),
-            query: (node, timeoutMs) => this.query(node, timeoutMs),
-            queryWithContext: this.queryWithContext.bind(this),
-            syncAppState: () => this.syncAppState().then(() => { }),
-            emitEvent: this.emit.bind(this),
-            handleIncomingMessageEvent: this.handleIncomingMessageEvent.bind(this),
-            handleError: this.handleError.bind(this),
-            scheduleReconnectAfterPairing: this.scheduleReconnectAfterPairing.bind(this),
-            updateClockSkewFromSuccess: this.updateClockSkewFromSuccess.bind(this),
-            getComms: () => this.comms,
-            getMediaConnCache: () => this.mediaConnCache,
-            setMediaConnCache: (mediaConn) => {
-                this.mediaConnCache = mediaConn;
-            },
-            disconnect: this.disconnect.bind(this),
-            clearStoredState: this.clearStoredState.bind(this),
-            connect: this.connect.bind(this),
-            shouldQueueDanglingReceipt: (node, error) => this.shouldQueueDanglingReceipt(node, error),
-            enqueueDanglingReceipt: this.enqueueDanglingReceipt.bind(this),
-            takeDanglingReceipts: () => this.danglingReceipts.splice(0)
-        };
         const dependencies = buildWaClientDependencies({
             base,
-            host
+            runtime: {
+                sendNode: (node) => this.sendNode(node),
+                query: (node, timeoutMs) => this.query(node, timeoutMs),
+                queryWithContext: this.queryWithContext.bind(this),
+                syncAppState: () => this.syncAppState().then(() => { }),
+                syncAppStateWithOptions: (syncOptions) => this.syncAppState(syncOptions),
+                emitEvent: this.emit.bind(this),
+                handleIncomingMessageEvent: this.handleIncomingMessageEvent.bind(this),
+                handleError: this.handleError.bind(this),
+                handleIncomingFrame: this.handleIncomingFrame.bind(this),
+                clearStoredState: this.clearStoredState.bind(this)
+            }
         });
         Object.assign(this, dependencies);
         this.bindNodeTransportEvents();
@@ -87,7 +67,7 @@ export class WaClient extends EventEmitter {
         return super.emit(event, ...args);
     }
     getState() {
-        const connected = this.comms !== null && this.comms.getCommsState().connected;
+        const connected = this.connectionManager.isConnected();
         this.logger.trace('wa client state requested', { connected });
         return this.authClient.getState(connected);
     }
@@ -95,7 +75,7 @@ export class WaClient extends EventEmitter {
         return this.authClient.getCurrentCredentials();
     }
     getClockSkewMs() {
-        return this.clockSkewMs;
+        return this.connectionManager.getClockSkewMs();
     }
     async sendNode(node) {
         try {
@@ -103,13 +83,13 @@ export class WaClient extends EventEmitter {
         }
         catch (error) {
             const normalized = toError(error);
-            if (this.shouldQueueDanglingReceipt(node, normalized)) {
-                this.enqueueDanglingReceipt(node);
+            if (this.receiptQueue.shouldQueue(node, normalized)) {
+                this.receiptQueue.enqueue(node);
                 this.logger.warn('queued dangling receipt after send failure', {
                     id: node.attrs.id,
                     to: node.attrs.to,
                     message: normalized.message,
-                    queueSize: this.danglingReceipts.length
+                    queueSize: this.receiptQueue.size()
                 });
                 return;
             }
@@ -117,7 +97,7 @@ export class WaClient extends EventEmitter {
         }
     }
     async query(node, timeoutMs = this.options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS) {
-        if (!this.comms || !this.comms.getCommsState().connected) {
+        if (!this.connectionManager.isConnected()) {
             throw new Error('client is not connected');
         }
         this.logger.debug('wa client query', { tag: node.tag, id: node.attrs.id, timeoutMs });
@@ -139,12 +119,17 @@ export class WaClient extends EventEmitter {
             this.handleError(error);
         });
     }
+    getMailboxPersistenceDeps() {
+        return {
+            logger: this.logger,
+            contactStore: this.contactStore,
+            messageStore: this.messageStore
+        };
+    }
     async handleIncomingMessageEvent(event) {
         this.emit('message', event);
         void persistIncomingMailboxEntities({
-            logger: this.logger,
-            contactStore: this.contactStore,
-            messageStore: this.messageStore,
+            ...this.getMailboxPersistenceDeps(),
             event
         });
         const protocolMessage = event.message?.protocolMessage;
@@ -209,9 +194,8 @@ export class WaClient extends EventEmitter {
                 imported
             });
             if (imported > 0) {
-                const hadWaiters = this.appStateKeyShareWaiters.size > 0;
-                this.appStateKeyShareVersion += 1;
-                this.notifyAppStateKeyShareWaiters(true);
+                const hadWaiters = this.keyShareCoordinator.hasWaiters();
+                this.keyShareCoordinator.notifyReceived();
                 if (hadWaiters) {
                     this.logger.debug('app-state key share imported and waiters released', {
                         id: event.stanzaId,
@@ -337,10 +321,8 @@ export class WaClient extends EventEmitter {
     async handleHistorySyncNotification(notification) {
         try {
             await processHistorySyncNotification({
-                logger: this.logger,
+                ...this.getMailboxPersistenceDeps(),
                 mediaTransfer: this.mediaTransfer,
-                contactStore: this.contactStore,
-                messageStore: this.messageStore,
                 threadStore: this.threadStore,
                 emitEvent: this.emit.bind(this)
             }, notification);
@@ -369,144 +351,98 @@ export class WaClient extends EventEmitter {
             this.logger.trace('wa client connect already in-flight');
             return this.connectPromise;
         }
-        this.connectPromise = this.connectInternal().finally(() => {
+        this.connectPromise = this.connectionManager
+            .connect((frame) => this.handleIncomingFrame(frame))
+            .then(() => {
+            this.emit('connection_open', {});
+        })
+            .finally(() => {
             this.connectPromise = null;
         });
         return this.connectPromise;
     }
-    async connectInternal() {
-        if (this.comms) {
-            this.logger.trace('wa client connect skipped: comms already created');
-            return;
-        }
-        this.logger.info('wa client connect start');
-        let credentials = await this.authClient.loadOrCreateCredentials();
-        try {
-            await this.startCommsWithCredentials(credentials);
-        }
-        catch (error) {
-            if (credentials.routingInfo) {
-                this.logger.warn('connect failed with routing info, retrying without routing info', {
-                    message: toError(error).message
-                });
-                await this.disconnect();
-                credentials = await this.authClient.clearRoutingInfo();
-                await this.startCommsWithCredentials(credentials);
-            }
-            else {
-                await this.disconnect();
-                throw error;
-            }
-        }
-        this.logger.info('wa client connected');
-        this.emit('connection_open', {});
-    }
-    scheduleReconnectAfterPairing() {
-        this.logger.debug('wa client scheduling reconnect after pairing');
-        setTimeout(() => {
-            void this.reconnectAsRegisteredAfterPairing().catch((error) => {
-                this.handleError(toError(error));
-            });
-        }, 0);
-    }
-    async reconnectAsRegisteredAfterPairing() {
-        if (this.pairingReconnectPromise) {
-            this.logger.trace('pairing reconnect already in-flight');
-            return this.pairingReconnectPromise;
-        }
-        this.pairingReconnectPromise = this.reconnectAsRegisteredAfterPairingInternal().finally(() => {
-            this.pairingReconnectPromise = null;
-        });
-        return this.pairingReconnectPromise;
-    }
-    async reconnectAsRegisteredAfterPairingInternal() {
-        const credentials = this.authClient.getCurrentCredentials();
-        if (!credentials?.meJid) {
-            this.logger.trace('pairing reconnect skipped: still unregistered');
-            return;
-        }
-        const currentComms = this.comms;
-        if (!currentComms) {
-            this.logger.trace('pairing reconnect skipped: no active comms');
-            return;
-        }
-        this.logger.info('pairing completed, restarting comms as registered');
-        this.keepAlive.stop();
-        this.nodeOrchestrator.clearPending(new Error('restarting comms after pairing'));
-        this.clearCommsBinding();
-        try {
-            await currentComms.stopComms();
-        }
-        catch (error) {
-            this.logger.warn('failed to stop pre-registration comms', {
-                message: toError(error).message
-            });
-        }
-        try {
-            await this.startCommsWithCredentials(credentials);
-        }
-        catch (error) {
-            this.logger.warn('pairing reconnect failed while starting registered comms', {
-                message: toError(error).message
-            });
-            throw error;
-        }
-    }
     async disconnect() {
-        this.logger.info('wa client disconnect start');
-        this.keepAlive.stop();
-        this.notifyAppStateKeyShareWaiters(false);
-        this.appStateBootstrapKeyShareWaitDone = false;
-        await this.authClient.clearTransientState();
-        this.nodeOrchestrator.clearPending(new Error('client disconnected'));
-        this.clockSkewMs = null;
-        this.mediaConnCache = null;
-        this.passiveTasks.resetInFlightState();
-        const comms = this.comms;
-        this.clearCommsBinding();
-        if (comms) {
-            await comms.stopComms();
-            this.logger.info('wa client disconnected');
-            this.emit('connection_close', {});
-        }
+        this.keyShareCoordinator.notifyDisconnected();
+        await this.connectionManager.disconnect();
+        this.emit('connection_close', {});
     }
     async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
-        if (!this.comms || !this.authClient.getCurrentCredentials()) {
+        if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
         this.logger.debug('wa client request pairing code');
         return this.authClient.requestPairingCode(phoneNumber, shouldShowPushNotification);
     }
     async fetchPairingCountryCodeIso() {
-        if (!this.comms || !this.authClient.getCurrentCredentials()) {
+        if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
         this.logger.trace('wa client fetch pairing country code iso');
         return this.authClient.fetchPairingCountryCodeIso();
     }
-    async sendMessage(to, content, options = {}) {
+    async getLidsByPhoneNumbers(phoneNumbers) {
+        if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
+            throw new Error('client is not connected');
+        }
+        const normalizedPhoneJids = phoneNumbers.map(parsePhoneJid);
+        this.logger.trace('wa client query lids by phone numbers', {
+            phones: normalizedPhoneJids.length
+        });
+        return this.signalDeviceSync.queryLidsByPhoneJids(normalizedPhoneJids);
+    }
+    sendMessage(to, content, options = {}) {
         return this.messageDispatch.sendMessage(to, content, options);
     }
-    async syncSignalSession(jid, reasonIdentity = false) {
-        await this.messageDispatch.syncSignalSession(jid, reasonIdentity);
+    syncSignalSession(jid, reasonIdentity = false) {
+        return this.messageDispatch.syncSignalSession(jid, reasonIdentity);
+    }
+    sendReceipt(input) {
+        return this.messageDispatch.sendReceipt(input);
+    }
+    setChatMute(chatJid, muted, muteEndTimestampMs) {
+        return this.appStateMutations.setChatMute(chatJid, muted, muteEndTimestampMs);
+    }
+    setChatRead(chatJid, read) {
+        return this.appStateMutations.setChatRead(chatJid, read);
+    }
+    setChatPin(chatJid, pinned) {
+        return this.appStateMutations.setChatPin(chatJid, pinned);
+    }
+    setChatArchive(chatJid, archived) {
+        return this.appStateMutations.setChatArchive(chatJid, archived);
     }
-    async sendReceipt(input) {
-        await this.messageDispatch.sendReceipt(input);
+    clearChat(chatJid, options = {}) {
+        return this.appStateMutations.clearChat(chatJid, options);
+    }
+    deleteChat(chatJid, options = {}) {
+        return this.appStateMutations.deleteChat(chatJid, options);
+    }
+    setChatLock(chatJid, locked) {
+        return this.appStateMutations.setChatLock(chatJid, locked);
+    }
+    setMessageStar(message, starred) {
+        return this.appStateMutations.setMessageStar(message, starred);
+    }
+    deleteMessageForMe(message, options = {}) {
+        return this.appStateMutations.deleteMessageForMe(message, options);
+    }
+    flushAppStateMutations() {
+        return this.appStateMutations.flushMutations();
     }
     async exportAppState() {
         return this.appStateSync.exportState();
     }
     async syncAppState(options = {}) {
-        if (!this.comms) {
+        if (!this.connectionManager.isConnected()) {
             throw new Error('client is not connected');
         }
         const shouldWaitForKeyShare = (await this.appStateStore.getActiveSyncKey()) === null;
-        if (shouldWaitForKeyShare && !this.appStateBootstrapKeyShareWaitDone) {
-            this.appStateBootstrapKeyShareWaitDone = true;
+        if (shouldWaitForKeyShare && !this.keyShareCoordinator.isBootstrapDone()) {
+            this.keyShareCoordinator.markBootstrapDone();
             this.logger.info('app-state bootstrap pre-sync waiting for key share', {
                 timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS
             });
-            const received = await this.waitForAppStateKeyShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
+            const received = await this.keyShareCoordinator.waitForShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
             if (received) {
                 this.logger.info('app-state bootstrap pre-sync received key share, continuing sync');
             }
@@ -523,17 +459,16 @@ export class WaClient extends EventEmitter {
             return syncResult;
         }
         let retryCount = 0;
-        let observedKeyShareVersion = this.appStateKeyShareVersion;
-        while (blockedCollections.length > 0 &&
-            retryCount < WA_APP_STATE_KEY_SHARE_MAX_RETRIES) {
-            const hasFreshShare = this.appStateKeyShareVersion !== observedKeyShareVersion;
+        let observedKeyShareVersion = this.keyShareCoordinator.getVersion();
+        while (blockedCollections.length > 0 && retryCount < WA_APP_STATE_KEY_SHARE_MAX_RETRIES) {
+            const hasFreshShare = this.keyShareCoordinator.getVersion() !== observedKeyShareVersion;
             if (!hasFreshShare) {
                 this.logger.info('app-state bootstrap waiting for key share', {
                     blockedCollections: blockedCollections.join(','),
                     timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS,
                     retryCount: retryCount + 1
                 });
-                const received = await this.waitForAppStateKeyShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
+                const received = await this.keyShareCoordinator.waitForShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
                 if (!received) {
                     this.logger.warn('app-state bootstrap key share wait timed out', {
                         blockedCollections: blockedCollections.join(','),
@@ -542,7 +477,7 @@ export class WaClient extends EventEmitter {
                     break;
                 }
             }
-            observedKeyShareVersion = this.appStateKeyShareVersion;
+            observedKeyShareVersion = this.keyShareCoordinator.getVersion();
             retryCount += 1;
             this.logger.info('app-state bootstrap retrying sync after key share', {
                 retryCount,
@@ -573,38 +508,6 @@ export class WaClient extends EventEmitter {
             .filter((entry) => entry.state === WA_APP_STATE_COLLECTION_STATES.BLOCKED)
             .map((entry) => entry.collection);
     }
-    async waitForAppStateKeyShare(timeoutMs) {
-        return new Promise((resolve) => {
-            let settled = false;
-            let timeoutHandle = null;
-            const waiter = (received) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                if (timeoutHandle) {
-                    clearTimeout(timeoutHandle);
-                    timeoutHandle = null;
-                }
-                this.appStateKeyShareWaiters.delete(waiter);
-                resolve(received);
-            };
-            this.appStateKeyShareWaiters.add(waiter);
-            timeoutHandle = setTimeout(() => {
-                waiter(false);
-            }, timeoutMs);
-        });
-    }
-    notifyAppStateKeyShareWaiters(received) {
-        if (this.appStateKeyShareWaiters.size === 0) {
-            return;
-        }
-        const waiters = [...this.appStateKeyShareWaiters.values()];
-        this.appStateKeyShareWaiters.clear();
-        for (const waiter of waiters) {
-            waiter(received);
-        }
-    }
     emitChatEventsFromAppStateSyncResult(syncResult) {
         const shouldEmitSnapshotMutations = this.options.chatEvents?.emitSnapshotMutations === true;
         for (const collectionResult of syncResult.collections) {
@@ -644,75 +547,13 @@ export class WaClient extends EventEmitter {
             }
         }
     }
-    async startCommsWithCredentials(credentials) {
-        this.logger.debug('starting comms with credentials', {
-            registered: credentials.meJid !== null && credentials.meJid !== undefined
-        });
-        const commsConfig = this.authClient.buildCommsConfig(this.options);
-        const comms = new WaComms(commsConfig, this.logger);
-        this.mediaConnCache = null;
-        this.nodeTransport.bindComms(comms);
-        try {
-            comms.startComms(async (frame) => this.handleIncomingFrame(frame));
-            await comms.waitForConnection(commsConfig.connectTimeoutMs);
-            this.comms = comms;
-            this.logger.info('comms connected');
-            comms.startHandlingRequests();
-            if (credentials.meJid) {
-                this.keepAlive.start();
-            }
-            else {
-                this.keepAlive.stop();
-            }
-            const serverStaticKey = comms.getServerStaticKey();
-            if (!serverStaticKey) {
-                this.logger.trace('no server static key available to persist');
-            }
-            else {
-                await this.authClient.persistServerStaticKey(serverStaticKey);
-                this.logger.debug('persisted server static key after comms connect');
-            }
-            this.passiveTasks.startPassiveTasksAfterConnect();
-        }
-        catch (error) {
-            this.clearCommsBinding();
-            try {
-                await comms.stopComms();
-            }
-            catch (stopError) {
-                this.logger.warn('failed to cleanup comms after connection start failure', {
-                    message: toError(stopError).message
-                });
-            }
-            throw error;
-        }
-    }
-    shouldQueueDanglingReceipt(node, error) {
-        if (node.tag !== WA_MESSAGE_TAGS.RECEIPT) {
-            return false;
-        }
-        const normalized = error.message.trim().toLowerCase();
-        return (normalized === 'comms is not connected' ||
-            normalized === 'websocket is not connected' ||
-            normalized === 'noise session socket closed' ||
-            normalized.startsWith('socket closed ('));
-    }
-    enqueueDanglingReceipt(node) {
-        if (this.danglingReceipts.length >= WA_DEFAULTS.MAX_DANGLING_RECEIPTS) {
-            this.danglingReceipts.shift();
-        }
-        this.danglingReceipts.push(node.content === undefined
-            ? {
-                tag: node.tag,
-                attrs: { ...node.attrs }
-            }
-            : {
-                tag: node.tag,
-                attrs: { ...node.attrs },
-                content: node.content
-            });
-    }
     async clearStoredState() {
+        const danglingReceipts = this.receiptQueue.take();
+        if (danglingReceipts.length > 0) {
+            this.logger.debug('cleared dangling receipts while clearing stored state', {
+                count: danglingReceipts.length
+            });
+        }
         await this.authClient.clearStoredCredentials();
         await this.appStateStore.clear();
         await this.contactStore.clear();
@@ -728,18 +569,4 @@ export class WaClient extends EventEmitter {
         this.logger.error('wa client error', { message: error.message });
         this.emit('client_error', { error });
     }
-    clearCommsBinding() {
-        this.notifyAppStateKeyShareWaiters(false);
-        this.comms = null;
-        this.nodeTransport.bindComms(null);
-    }
-    updateClockSkewFromSuccess(serverUnixSeconds) {
-        const serverMs = serverUnixSeconds * 1000;
-        const nowMs = Date.now();
-        this.clockSkewMs = serverMs - nowMs;
-        this.logger.debug('updated clock skew from success', {
-            serverUnixSeconds,
-            clockSkewMs: this.clockSkewMs
-        });
-    }
 }