zapo-js 0.1.2 → 0.2.0

package/dist/esm/client/WaClientFactory.js

@@ -4,13 +4,20 @@ import { WaConnectionManager } from './connection/WaConnectionManager.js';
 import { WaKeyShareCoordinator } from './connection/WaKeyShareCoordinator.js';
 import { WaReceiptQueue } from './connection/WaReceiptQueue.js';
 import { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator.js';
+import { createBusinessCoordinator } from './coordinators/WaBusinessCoordinator.js';
 import { createGroupCoordinator } from './coordinators/WaGroupCoordinator.js';
 import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator.js';
 import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator.js';
 import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator.js';
+import { createPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator.js';
+import { createProfileCoordinator } from './coordinators/WaProfileCoordinator.js';
 import { WaRetryCoordinator } from './coordinators/WaRetryCoordinator.js';
 import { createStreamControlHandler } from './coordinators/WaStreamControlCoordinator.js';
+import { WaTrustedContactTokenCoordinator } from './coordinators/WaTrustedContactTokenCoordinator.js';
 import { handleDirtyBits, parseDirtyBits } from './dirty.js';
+import { DEVICE_NOTIFICATION_ACTIONS, parseDeviceNotification } from './events/devices.js';
+import { parseIdentityChangeNotification } from './events/identity.js';
+import { parsePrivacyTokenNotification } from './events/privacy-token.js';
 import { buildMediaMessageContent, getMediaConn as getClientMediaConn } from './messages.js';
 import { createDeviceFanoutResolver } from './messaging/fanout.js';
 import { createAppStateSyncKeyProtocol } from './messaging/key-protocol.js';
@@ -18,7 +25,8 @@ import { createGroupParticipantsCache } from './messaging/participants.js';
 import { WaMediaTransferClient } from '../media/WaMediaTransferClient.js';
 import { handleIncomingMessageAck } from '../message/incoming.js';
 import { WaMessageClient } from '../message/WaMessageClient.js';
-import { getWaCompanionPlatformId, WA_DEFAULTS } from '../protocol/constants.js';
+import { getWaCompanionPlatformId, WA_DEFAULTS, WA_DISCONNECT_REASONS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES, WA_PRIVACY_TOKEN_NOTIFICATION_TYPE } from '../protocol/constants.js';
+import { parseSignalAddressFromJid, toUserJid } from '../protocol/jid.js';
 import { createOutboundRetryTracker } from '../retry/tracker.js';
 import { SignalDeviceSyncApi } from '../signal/api/SignalDeviceSyncApi.js';
 import { SignalDigestSyncApi } from '../signal/api/SignalDigestSyncApi.js';
@@ -30,6 +38,8 @@ import { SenderKeyManager } from '../signal/group/SenderKeyManager.js';
 import { createSignalSessionResolver } from '../signal/session/resolver.js';
 import { SignalProtocol } from '../signal/session/SignalProtocol.js';
 import { WaKeepAlive } from '../transport/keepalive/WaKeepAlive.js';
+import { buildAckNode } from '../transport/node/builders/global.js';
+import { getFirstNodeChild } from '../transport/node/helpers.js';
 import { createUsyncSidGenerator } from '../transport/node/usync.js';
 import { WaNodeOrchestrator } from '../transport/node/WaNodeOrchestrator.js';
 import { WaNodeTransport } from '../transport/node/WaNodeTransport.js';
@@ -90,31 +100,6 @@ export function resolveWaClientBase(options, logger) {
         sessionStore
     };
 }
-function createIncomingMessageAckOptions(input) {
-    const { logger, sendNode, emitEvent, handleIncomingMessageEvent, handleError, getCurrentMeJid, signalProtocol, senderKeyManager, retryCoordinator } = input;
-    return {
-        logger,
-        sendNode,
-        getMeJid: getCurrentMeJid,
-        signalProtocol,
-        senderKeyManager,
-        onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
-        emitIncomingMessage: (event) => {
-            void handleIncomingMessageEvent(event).catch((err) => handleError(toError(err)));
-        },
-        emitUnhandledStanza: (event) => emitEvent('stanza_unhandled', event)
-    };
-}
-function createHandleClientDirtyBits(input) {
-    const { logger, queryWithContext, syncAppState, getCurrentCredentials, generateUsyncSid } = input;
-    return (dirtyBits) => handleDirtyBits({
-        logger,
-        queryWithContext,
-        getCurrentCredentials,
-        syncAppState,
-        generateUsyncSid
-    }, dirtyBits);
-}
 function createIncomingNodeRuntime(input) {
     const { logger, emitEvent, authClient, connectionManager, nodeOrchestrator, streamControl, mediaMessageBuildOptions, retryCoordinator, messageDispatch, sendNode, syncAppState, disconnect, clearStoredCredentials, getCurrentMeJid, handleClientDirtyBits, incomingMessageAckOptions } = input;
     return {
@@ -156,6 +141,9 @@ function createIncomingNodeRuntime(input) {
         },
         emitUnhandledIncomingNode: (event) => emitEvent('stanza_unhandled', event),
         syncAppState,
+        stopComms: () => {
+            void connectionManager.getComms()?.stopComms();
+        },
         disconnect,
         clearStoredCredentials,
         parseDirtyBits: (nodes) => parseDirtyBits(nodes, logger),
@@ -272,7 +260,8 @@ export function buildWaClientDependencies(input) {
         deviceBrowser: options.deviceBrowser,
         deviceOsDisplayName: options.deviceOsDisplayName,
         devicePlatform: options.devicePlatform,
-        requireFullSync: options.requireFullSync
+        requireFullSync: options.requireFullSync,
+        version: options.version
     }, {
         logger,
         authStore: sessionStore.auth,
@@ -299,6 +288,16 @@ export function buildWaClientDependencies(input) {
     const groupCoordinator = createGroupCoordinator({
         queryWithContext: runtime.queryWithContext
     });
+    const privacyCoordinator = createPrivacyCoordinator({
+        queryWithContext: runtime.queryWithContext
+    });
+    const profileCoordinator = createProfileCoordinator({
+        queryWithContext: runtime.queryWithContext,
+        generateSid: generateUsyncSid
+    });
+    const businessCoordinator = createBusinessCoordinator({
+        queryWithContext: runtime.queryWithContext
+    });
     const retryTracker = createOutboundRetryTracker({
         retryStore: sessionStore.retry,
         logger
@@ -318,9 +317,30 @@ export function buildWaClientDependencies(input) {
     });
     const participantsCache = createGroupParticipantsCache({
         participantsStore: sessionStore.participants,
-        queryGroupParticipantJids: async (groupJid) => (await groupCoordinator.queryGroupMetadata(groupJid)).participants.map((participant) => participant.jid),
+        queryGroupParticipantJids: async (groupJid) => {
+            const metadata = await groupCoordinator.queryGroupMetadata(groupJid);
+            const participantJids = new Array(metadata.participants.length);
+            for (let index = 0; index < metadata.participants.length; index += 1) {
+                participantJids[index] = metadata.participants[index].jid;
+            }
+            return participantJids;
+        },
         logger
     });
+    const trustedContactToken = new WaTrustedContactTokenCoordinator({
+        logger,
+        store: sessionStore.privacyToken,
+        runtime: {
+            queryWithContext: runtime.queryWithContext,
+            emitEvent: runtime.emitEvent,
+            getCurrentMeLid: () => getCurrentMeLid() ?? null
+        },
+        durationS: options.privacyToken?.tcTokenDurationS,
+        numBuckets: options.privacyToken?.tcTokenNumBuckets,
+        senderDurationS: options.privacyToken?.tcTokenSenderDurationS,
+        senderNumBuckets: options.privacyToken?.tcTokenSenderNumBuckets,
+        maxDurationS: options.privacyToken?.tcTokenMaxDurationS
+    });
     let messageDispatch;
     const appStateSyncKeyProtocol = createAppStateSyncKeyProtocol({
         publishSignalMessage: (signalInput, publishOptions) => messageDispatch.publishSignalMessage(signalInput, publishOptions),
@@ -340,9 +360,18 @@ export function buildWaClientDependencies(input) {
         buildMessageContent: async (content) => buildMediaMessageContent(mediaMessageBuildOptions, content),
         senderKeyManager,
         signalProtocol,
+        signalStore: sessionStore.signal,
+        deviceListStore: sessionStore.deviceList,
         getCurrentMeJid,
         getCurrentMeLid,
-        getCurrentSignedIdentity
+        getCurrentSignedIdentity,
+        resolvePrivacyTokenNode: (recipientJid) => trustedContactToken.resolveTokenForMessage(recipientJid),
+        onDirectMessageSent: (recipientJid) => {
+            trustedContactToken.maybeIssueSenderToken(recipientJid).catch((err) => logger.warn('sender token issue failed', {
+                to: recipientJid,
+                message: toError(err).message
+            }));
+        }
     });
     const retryCoordinator = new WaRetryCoordinator({
         logger,
@@ -387,14 +416,27 @@ export function buildWaClientDependencies(input) {
         connectionManager.setMediaConnCache(mediaConnCacheFallback);
     }
     scheduleReconnectAfterPairing = () => connectionManager?.scheduleReconnectAfterPairing();
-    const disconnectWithClientSideEffects = async () => {
+    const disconnectWithClientSideEffects = async (reason, isLogout, code) => {
         keyShareCoordinator.notifyDisconnected();
         await connectionManager?.disconnect();
-        runtime.emitEvent('connection_close', {});
+        runtime.emitEvent('connection', {
+            status: 'close',
+            reason,
+            code,
+            isLogout,
+            isNewLogin: false
+        });
     };
-    const connectWithClientSideEffects = async () => {
+    const connectWithClientSideEffects = async (reason) => {
+        runtime.resumeIncomingEvents();
         await connectionManager?.connect(runtime.handleIncomingFrame);
-        runtime.emitEvent('connection_open', {});
+        runtime.emitEvent('connection', {
+            status: 'open',
+            reason,
+            code: null,
+            isLogout: false,
+            isNewLogin: connectionManager?.wasNewLogin() ?? false
+        });
     };
     const clearStoredCredentialsWithClientSideEffects = async () => {
         await connectionManager?.clearStoredCredentials();
@@ -411,24 +453,27 @@ export function buildWaClientDependencies(input) {
         clearStoredCredentials: clearStoredCredentialsWithClientSideEffects,
         connect: connectWithClientSideEffects
     });
-    const incomingMessageAckOptions = createIncomingMessageAckOptions({
+    const incomingMessageAckOptions = {
         logger,
         sendNode: runtime.sendNode,
-        emitEvent: runtime.emitEvent,
-        handleIncomingMessageEvent: runtime.handleIncomingMessageEvent,
-        handleError: runtime.handleError,
-        getCurrentMeJid,
+        getMeJid: getCurrentMeJid,
         signalProtocol,
         senderKeyManager,
-        retryCoordinator
-    });
-    const handleClientDirtyBits = createHandleClientDirtyBits({
+        onDecryptFailure: (context, error) => retryCoordinator.onDecryptFailure(context, error),
+        emitIncomingMessage: (event) => {
+            void runtime
+                .handleIncomingMessageEvent(event)
+                .catch((err) => runtime.handleError(toError(err)));
+        },
+        emitUnhandledStanza: (event) => runtime.emitEvent('stanza_unhandled', event)
+    };
+    const handleClientDirtyBits = (dirtyBits) => handleDirtyBits({
         logger,
         queryWithContext: runtime.queryWithContext,
-        syncAppState: runtime.syncAppState,
         getCurrentCredentials,
+        syncAppState: runtime.syncAppState,
         generateUsyncSid
-    });
+    }, dirtyBits);
     const incomingNode = new WaIncomingNodeCoordinator({
         logger,
         runtime: createIncomingNodeRuntime({
@@ -450,6 +495,207 @@ export function buildWaClientDependencies(input) {
             incomingMessageAckOptions
         })
     });
+    incomingNode.registerIncomingHandler({
+        tag: WA_NODE_TAGS.NOTIFICATION,
+        subtype: WA_NOTIFICATION_TYPES.ENCRYPT,
+        prepend: true,
+        handler: async (node) => {
+            const firstChild = getFirstNodeChild(node);
+            if (!firstChild) {
+                return false;
+            }
+            const childTag = firstChild.tag;
+            // <count value="N"/> — server prekeys running low
+            if (childTag === 'count') {
+                const ackNode = buildAckNode({
+                    kind: 'notification',
+                    node,
+                    includeType: false
+                });
+                await runtime.sendNode(ackNode);
+                const tasks = passiveTasks;
+                if (!tasks) {
+                    logger.warn('encrypt-count: passive tasks not available');
+                    return true;
+                }
+                await tasks.handlePreKeyLowNotification().catch((error) => {
+                    logger.warn('encrypt-count: prekey upload failed', {
+                        message: toError(error).message
+                    });
+                });
+                return true;
+            }
+            // <digest/> — digest key sync
+            if (childTag === 'digest') {
+                const ackNode = buildAckNode({
+                    kind: 'notification',
+                    node,
+                    includeType: false
+                });
+                await runtime.sendNode(ackNode);
+                const tasks = passiveTasks;
+                if (!tasks) {
+                    logger.warn('encrypt-digest: passive tasks not available');
+                    return true;
+                }
+                await tasks.handleDigestNotification().catch((error) => {
+                    logger.warn('encrypt-digest: digest sync failed', {
+                        message: toError(error).message
+                    });
+                });
+                return true;
+            }
+            // <identity/> — contact identity key changed
+            if (childTag === 'identity') {
+                const parsed = parseIdentityChangeNotification(node);
+                if (!parsed) {
+                    return false;
+                }
+                const ackNode = buildAckNode({
+                    kind: 'notification',
+                    node,
+                    includeType: false
+                });
+                await runtime.sendNode(ackNode);
+                const address = parseSignalAddressFromJid(parsed.fromJid);
+                // ignore companion devices (non-primary)
+                if (address.device !== 0) {
+                    logger.debug('identity-change: ignoring companion device', {
+                        jid: parsed.fromJid
+                    });
+                    return true;
+                }
+                // self-primary identity change → must disconnect
+                const meJid = getCurrentMeJid();
+                if (meJid) {
+                    const meUser = toUserJid(meJid);
+                    const fromUser = toUserJid(parsed.fromJid);
+                    if (meUser === fromUser) {
+                        logger.error('self primary identity changed, disconnecting');
+                        void connectionManager?.getComms()?.stopComms();
+                        await disconnectWithClientSideEffects(WA_DISCONNECT_REASONS.PRIMARY_IDENTITY_KEY_CHANGE, true, null);
+                        await clearStoredCredentialsWithClientSideEffects();
+                        return true;
+                    }
+                }
+                const oldIdentity = await sessionStore.signal.getRemoteIdentity(address);
+                if (oldIdentity) {
+                    logger.info('identity-change: clearing session', {
+                        jid: parsed.fromJid
+                    });
+                    await sessionStore.signal.deleteSession(address);
+                    const userJid = toUserJid(parsed.fromJid);
+                    await trustedContactToken.reissueOnIdentityChange(userJid).catch((error) => {
+                        logger.warn('identity-change: reissue tc token failed', {
+                            message: toError(error).message
+                        });
+                    });
+                }
+                runtime.emitEvent('notification', {
+                    rawNode: node,
+                    stanzaId: parsed.stanzaId,
+                    chatJid: parsed.fromJid,
+                    stanzaType: 'encrypt',
+                    notificationType: 'encrypt',
+                    classification: 'core',
+                    details: {
+                        kind: 'identity_change',
+                        displayName: parsed.displayName,
+                        lid: parsed.lid,
+                        hadPreviousIdentity: !!oldIdentity
+                    }
+                });
+                return true;
+            }
+            return false;
+        }
+    });
+    incomingNode.registerIncomingHandler({
+        tag: WA_NODE_TAGS.NOTIFICATION,
+        subtype: WA_NOTIFICATION_TYPES.DEVICES,
+        prepend: true,
+        handler: async (node) => {
+            const parsed = parseDeviceNotification(node);
+            if (!parsed) {
+                return false;
+            }
+            const ackNode = buildAckNode({
+                kind: 'notification',
+                node,
+                includeType: false
+            });
+            await runtime.sendNode(ackNode);
+            const userJid = toUserJid(parsed.fromJid);
+            if (parsed.action === DEVICE_NOTIFICATION_ACTIONS.REMOVE) {
+                const baseAddress = parseSignalAddressFromJid(parsed.fromJid);
+                for (const device of parsed.devices) {
+                    const address = {
+                        user: baseAddress.user,
+                        server: baseAddress.server,
+                        device: device.deviceId
+                    };
+                    await sessionStore.signal.deleteSession(address).catch((error) => {
+                        logger.warn('devices-notification: delete session failed', {
+                            message: toError(error).message
+                        });
+                    });
+                }
+            }
+            // invalidate device list cache so next fanout fetches fresh list
+            if (sessionStore.deviceList) {
+                await sessionStore.deviceList.deleteUserDevices(userJid).catch((error) => {
+                    logger.warn('devices-notification: invalidate cache failed', {
+                        message: toError(error).message
+                    });
+                });
+            }
+            // for update notifications, re-sync immediately
+            if (parsed.action === DEVICE_NOTIFICATION_ACTIONS.UPDATE) {
+                signalDeviceSync.syncDeviceList([userJid]).catch((error) => {
+                    logger.warn('devices-notification: sync device list failed', {
+                        message: toError(error).message
+                    });
+                });
+            }
+            runtime.emitEvent('notification', {
+                rawNode: node,
+                stanzaId: parsed.stanzaId,
+                chatJid: parsed.fromJid,
+                stanzaType: 'devices',
+                notificationType: 'devices',
+                classification: 'core',
+                details: {
+                    kind: 'device_list_change',
+                    action: parsed.action,
+                    devices: parsed.devices
+                }
+            });
+            return true;
+        }
+    });
+    incomingNode.registerIncomingHandler({
+        tag: WA_NODE_TAGS.NOTIFICATION,
+        subtype: WA_PRIVACY_TOKEN_NOTIFICATION_TYPE,
+        prepend: true,
+        handler: async (node) => {
+            const fromJid = node.attrs.from ?? node.attrs.sender_lid;
+            if (!fromJid) {
+                return false;
+            }
+            const tokens = parsePrivacyTokenNotification(node);
+            if (tokens.length === 0) {
+                return false;
+            }
+            await trustedContactToken.handleIncomingToken(fromJid, tokens);
+            const ackNode = buildAckNode({
+                kind: 'notification',
+                node,
+                typeOverride: WA_PRIVACY_TOKEN_NOTIFICATION_TYPE
+            });
+            await runtime.sendNode(ackNode);
+            return true;
+        }
+    });
     passiveTasks = new WaPassiveTasksCoordinator({
         logger,
         signalStore: sessionStore.signal,
@@ -482,13 +728,17 @@ export function buildWaClientDependencies(input) {
         messageDispatch,
         retryCoordinator,
         appStateSync,
-        appStateMutations,
+        chatCoordinator: appStateMutations,
         streamControl,
         incomingNode,
         passiveTasks,
         groupCoordinator,
+        privacyCoordinator,
+        profileCoordinator,
+        businessCoordinator,
         receiptQueue,
         keyShareCoordinator,
-        connectionManager
+        connectionManager,
+        trustedContactToken
     };
 }

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

@@ -2,6 +2,7 @@ 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;
@@ -30,11 +31,12 @@ export class WaConnectionManager {
         const operation = this.runLifecycleOperation(async () => {
             await this.connectInternal(frameHandler, lifecycleGeneration);
         });
-        this.connectPromise = operation.finally(() => {
-            if (this.connectPromise === operation) {
+        const promise = operation.finally(() => {
+            if (this.connectPromise === promise) {
                 this.connectPromise = null;
             }
         });
+        this.connectPromise = promise;
         return this.connectPromise;
     }
     scheduleReconnectAfterPairing() {
@@ -64,6 +66,9 @@ export class WaConnectionManager {
     isConnected() {
         return !!(this.comms && this.comms.getCommsState().connected);
     }
+    wasNewLogin() {
+        return this.lastConnectWasNewLogin;
+    }
     getComms() {
         return this.comms;
     }
@@ -93,6 +98,7 @@ export class WaConnectionManager {
         }
         this.logger.info('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);
@@ -127,11 +133,12 @@ export class WaConnectionManager {
         const operation = this.runLifecycleOperation(async () => {
             await this.reconnectAsRegisteredAfterPairingInternal();
         });
-        this.pairingReconnectPromise = operation.finally(() => {
-            if (this.pairingReconnectPromise === operation) {
+        const promise = operation.finally(() => {
+            if (this.pairingReconnectPromise === promise) {
                 this.pairingReconnectPromise = null;
             }
         });
+        this.pairingReconnectPromise = promise;
         return this.pairingReconnectPromise;
     }
     async reconnectAsRegisteredAfterPairingInternal() {
@@ -176,12 +183,14 @@ export class WaConnectionManager {
         this.pendingComms = null;
         this.clearCommsBinding(currentComms ?? undefined);
         await this.authClient.clearTransientState();
-        if (pendingComms) {
-            await this.stopCommsQuietly(pendingComms, 'failed to stop pending comms during disconnect');
-        }
-        if (currentComms) {
-            await this.stopCommsQuietly(currentComms, 'failed to stop comms during disconnect');
-        }
+        await Promise.all([
+            pendingComms && pendingComms !== currentComms
+                ? this.stopCommsQuietly(pendingComms, 'failed to stop pending comms during disconnect')
+                : Promise.resolve(),
+            currentComms
+                ? this.stopCommsQuietly(currentComms, 'failed to stop comms during disconnect')
+                : Promise.resolve()
+        ]);
         if (this.isLifecycleCurrent(lifecycleGeneration)) {
             this.logger.info('wa client disconnected');
         }