zapo-js 0.2.0 → 1.0.0

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

@@ -0,0 +1,46 @@
+import { proto } from '../../proto.js';
+import { WA_DEFAULTS } from '../../protocol/defaults.js';
+/** Builds a {@link WaStatusCoordinator} from its dependencies. */
+export function createStatusCoordinator(options) {
+    return {
+        setPrivacy: (input) => options.appStateMutations.setStatusPrivacy(input),
+        setUserMuted: (jid, muted) => options.appStateMutations.setUserStatusMute(jid, muted),
+        send: async (input) => {
+            const built = await options.buildMessageContent(input.content);
+            const message = built.message.conversation && !built.message.extendedTextMessage
+                ? {
+                    ...built.message,
+                    conversation: null,
+                    extendedTextMessage: {
+                        text: built.message.conversation
+                    }
+                }
+                : built.message;
+            const published = await options.publishStatusMessage({
+                message,
+                recipients: input.recipients,
+                statusSetting: input.statusSetting,
+                options: input.options
+            });
+            return built.upload ? { ...published, upload: built.upload } : published;
+        },
+        revokeStatus: async (input) => {
+            const message = {
+                protocolMessage: {
+                    type: proto.Message.ProtocolMessage.Type.REVOKE,
+                    key: {
+                        remoteJid: WA_DEFAULTS.STATUS_BROADCAST_JID,
+                        fromMe: true,
+                        id: input.messageId
+                    }
+                }
+            };
+            return options.publishStatusMessage({
+                message,
+                recipients: input.recipients,
+                statusSetting: input.statusSetting,
+                options: input.options
+            });
+        }
+    };
+}

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

@@ -82,7 +82,7 @@ export function createStreamControlHandler(options) {
     return {
         handleStreamControlResult: async (result) => {
             switch (result.kind) {
-                case 'xmlstreamend':
+                case WA_STREAM_SIGNALING.XML_STREAM_END_TAG:
                     logger.info('received xmlstreamend stanza');
                     return;
                 case 'stream_error_code':
@@ -99,23 +99,23 @@ export function createStreamControlHandler(options) {
                     }
                     await resumeSocketDueToStreamError(`stream_error_code_${result.code}`);
                     return;
-                case 'stream_error_replaced':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED:
                     logger.warn('received stream:error replaced, stopping client');
                     await disconnectDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED, null);
                     return;
-                case 'stream_error_device_removed':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED:
                     logger.warn('received stream:error device removed, logging out');
                     await logoutDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED, null, false);
                     return;
-                case 'stream_error_ack':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_ACK:
                     logger.warn('received stream:error ack', { id: result.id });
                     await resumeSocketDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_ACK);
                     return;
-                case 'stream_error_xml_not_well_formed':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_XML_NOT_WELL_FORMED:
                     logger.warn('received stream:error xml-not-well-formed');
                     await resumeSocketDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_XML_NOT_WELL_FORMED);
                     return;
-                case 'stream_error_other':
+                case WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER:
                     logger.warn('received stream:error other');
                     await resumeSocketDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER);
                     return;

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

@@ -1,8 +1,8 @@
 import { CsTokenGenerator } from '../tokens/cs-token.js';
-import { isTokenExpired, shouldSendNewToken, clampDuration } from '../tokens/tc-token.js';
+import { clampDuration, isTokenExpired, shouldSendNewToken } from '../tokens/tc-token.js';
 import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from '../../protocol/privacy-token.js';
-import { buildPrivacyTokenIqNode, buildTcTokenMessageNode, buildCsTokenMessageNode } from '../../transport/node/builders/privacy-token.js';
+import { buildCsTokenMessageNode, buildPrivacyTokenIqNode, buildTcTokenMessageNode } from '../../transport/node/builders/privacy-token.js';
 import { toError } from '../../util/primitives.js';
 const NCT_SALT_SENTINEL_JID = '__nct_salt__';
 export class WaTrustedContactTokenCoordinator {
@@ -10,36 +10,53 @@ export class WaTrustedContactTokenCoordinator {
         this.logger = options.logger;
         this.store = options.store;
         this.runtime = options.runtime;
+        this.serverClock = options.serverClock;
         const maxDurationS = options.maxDurationS ?? WA_TC_TOKEN_DEFAULTS.MAX_DURATION_S;
-        this.config = {
+        this.baseConfig = {
             durationS: clampDuration(options.durationS ?? WA_TC_TOKEN_DEFAULTS.DURATION_S, maxDurationS),
             numBuckets: options.numBuckets ?? WA_TC_TOKEN_DEFAULTS.NUM_BUCKETS,
             senderDurationS: clampDuration(options.senderDurationS ?? WA_TC_TOKEN_DEFAULTS.SENDER_DURATION_S, maxDurationS),
             senderNumBuckets: options.senderNumBuckets ?? WA_TC_TOKEN_DEFAULTS.SENDER_NUM_BUCKETS,
             maxDurationS
         };
+        this.getConfigOverrides = options.getConfigOverrides;
         this.csTokenGenerator = new CsTokenGenerator();
         this.senderTokenDedup = new PromiseDedup();
         this.cachedNctSalt = null;
         this.nctSaltHydrated = false;
     }
+    resolveConfig() {
+        const overrides = this.getConfigOverrides?.();
+        if (!overrides) {
+            return this.baseConfig;
+        }
+        const maxDurationS = overrides.maxDurationS ?? this.baseConfig.maxDurationS;
+        return {
+            durationS: clampDuration(overrides.durationS ?? this.baseConfig.durationS, maxDurationS),
+            numBuckets: overrides.numBuckets ?? this.baseConfig.numBuckets,
+            senderDurationS: clampDuration(overrides.senderDurationS ?? this.baseConfig.senderDurationS, maxDurationS),
+            senderNumBuckets: overrides.senderNumBuckets ?? this.baseConfig.senderNumBuckets,
+            maxDurationS
+        };
+    }
     async resolveTokenForMessage(recipientJid) {
         const record = await this.store.getByJid(recipientJid);
-        const nowS = Math.floor(Date.now() / 1000);
+        const nowS = this.serverClock.nowSeconds();
+        const config = this.resolveConfig();
         if (record?.tcToken &&
             record.tcTokenTimestamp !== undefined &&
-            !isTokenExpired(record.tcTokenTimestamp, nowS, this.config.durationS, this.config.numBuckets)) {
+            !isTokenExpired(record.tcTokenTimestamp, nowS, config.durationS, config.numBuckets)) {
             return buildTcTokenMessageNode(record.tcToken);
         }
         const nctSalt = await this.getNctSalt();
         if (!nctSalt) {
             return null;
         }
-        const meLid = this.runtime.getCurrentMeLid();
+        const meLid = this.runtime.getCurrentCredentials()?.meLid;
         if (!meLid) {
             return null;
         }
-        const hash = await this.csTokenGenerator.generate(nctSalt, meLid);
+        const hash = this.csTokenGenerator.generate(nctSalt, meLid);
         return buildCsTokenMessageNode(hash);
     }
     async handleIncomingToken(fromJid, tokens) {
@@ -56,7 +73,7 @@ export class WaTrustedContactTokenCoordinator {
                 tcTokenTimestamp: token.timestampS,
                 updatedAtMs: nowMs
             });
-            this.runtime.emitEvent('privacy_token_update', {
+            this.runtime.emitEvent('debug_privacy_token', {
                 jid: fromJid,
                 timestampS: token.timestampS,
                 type: token.type,
@@ -66,11 +83,12 @@ export class WaTrustedContactTokenCoordinator {
     }
     async maybeIssueSenderToken(recipientJid) {
         return this.senderTokenDedup.run(recipientJid, async () => {
-            const nowS = Math.floor(Date.now() / 1000);
+            const nowS = this.serverClock.nowSeconds();
             const record = await this.store.getByJid(recipientJid);
             const senderTimestampS = record?.tcTokenSenderTimestamp;
+            const config = this.resolveConfig();
             if (senderTimestampS !== undefined && senderTimestampS > 0) {
-                if (!shouldSendNewToken(senderTimestampS, nowS, this.config.senderDurationS)) {
+                if (!shouldSendNewToken(senderTimestampS, nowS, config.senderDurationS)) {
                     return;
                 }
             }
@@ -87,8 +105,9 @@ export class WaTrustedContactTokenCoordinator {
         if (!record?.tcTokenSenderTimestamp) {
             return;
         }
-        const nowS = Math.floor(Date.now() / 1000);
-        if (isTokenExpired(record.tcTokenSenderTimestamp, nowS, this.config.senderDurationS, this.config.senderNumBuckets)) {
+        const nowS = this.serverClock.nowSeconds();
+        const config = this.resolveConfig();
+        if (isTokenExpired(record.tcTokenSenderTimestamp, nowS, config.senderDurationS, config.senderNumBuckets)) {
             return;
         }
         try {

package/dist/esm/client/events/abprops.js

@@ -0,0 +1,40 @@
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+export function parseAbPropsIqResult(node) {
+    const propsNode = findNodeChild(node, 'props');
+    if (!propsNode) {
+        return {
+            abKey: null,
+            hash: null,
+            refresh: null,
+            refreshId: null,
+            isDeltaUpdate: false,
+            props: []
+        };
+    }
+    const attrs = propsNode.attrs;
+    const propChildren = getNodeChildren(propsNode);
+    const props = [];
+    for (let i = 0; i < propChildren.length; i += 1) {
+        const child = propChildren[i];
+        if (child.tag !== 'prop') {
+            continue;
+        }
+        const configCode = parseOptionalInt(child.attrs.config_code);
+        if (configCode === undefined) {
+            continue;
+        }
+        props.push({
+            configCode,
+            configValue: child.attrs.config_value ?? null
+        });
+    }
+    return {
+        abKey: attrs.ab_key ?? null,
+        hash: attrs.hash ?? null,
+        refresh: parseOptionalInt(attrs.refresh) ?? null,
+        refreshId: parseOptionalInt(attrs.refresh_id) ?? null,
+        isDeltaUpdate: attrs.delta_update === 'true',
+        props
+    };
+}

package/dist/esm/client/events/appstate-mutation.js

@@ -0,0 +1,130 @@
+import { decodeEnumValue, decodeIndexArgsFromSchema, getAppstateSchemaByActionName } from '../../appstate-spec.js';
+export function parseAppStateMutationEvent(mutation) {
+    const parts = parseIndexParts(mutation.index);
+    if (!parts || parts.length === 0) {
+        return null;
+    }
+    const resolved = getAppstateSchemaByActionName(parts[0]);
+    if (!resolved) {
+        return null;
+    }
+    const indexArgs = decodeIndexArgsFromSchema(resolved.schema, parts);
+    if (!indexArgs) {
+        return null;
+    }
+    const valueRaw = mutation.value ?? null;
+    const base = {
+        source: mutation.source,
+        collection: mutation.collection,
+        version: mutation.version,
+        timestamp: mutation.timestamp,
+        _raw: { index: mutation.index, indexParts: parts, value: valueRaw }
+    };
+    if (mutation.operation === 'remove') {
+        return {
+            schema: resolved.key,
+            operation: 'remove',
+            ...indexArgs,
+            ...base
+        };
+    }
+    const data = unwrapData(resolved.schema, valueRaw);
+    return {
+        schema: resolved.key,
+        operation: 'set',
+        ...indexArgs,
+        ...(data ?? {}),
+        ...base
+    };
+}
+function unwrapData(schema, value) {
+    if (!value) {
+        return null;
+    }
+    const field = schema.valueField;
+    let inner;
+    if (field === null) {
+        const rest = {};
+        for (const key of Object.keys(value)) {
+            if (key === 'timestamp')
+                continue;
+            rest[key] = value[key];
+        }
+        inner = rest;
+    }
+    else {
+        const sub = value[field];
+        if (sub === null || sub === undefined || typeof sub !== 'object') {
+            return null;
+        }
+        inner = { ...sub };
+    }
+    applyEnumDecodeToData(schema.valueEnumFields, inner);
+    return inner;
+}
+function applyEnumDecodeToData(enumFields, data) {
+    if (!enumFields)
+        return;
+    for (const [fieldPath, enumPath] of Object.entries(enumFields)) {
+        applyDecodeAtPath(data, fieldPath.split('.'), (raw) => {
+            if (typeof raw !== 'number')
+                return raw;
+            const name = decodeEnumValue(enumPath, raw);
+            return name ?? raw;
+        });
+    }
+}
+function applyDecodeAtPath(obj, segments, transform) {
+    if (segments.length === 0)
+        return;
+    const [head, ...rest] = segments;
+    if (rest.length === 0) {
+        if (head in obj) {
+            const value = obj[head];
+            if (Array.isArray(value)) {
+                obj[head] = value.map(transform);
+            }
+            else if (value !== null && value !== undefined) {
+                obj[head] = transform(value);
+            }
+        }
+        return;
+    }
+    const next = obj[head];
+    if (Array.isArray(next)) {
+        for (const item of next) {
+            if (item && typeof item === 'object') {
+                applyDecodeAtPath(item, rest, transform);
+            }
+        }
+        return;
+    }
+    if (next && typeof next === 'object') {
+        applyDecodeAtPath(next, rest, transform);
+    }
+}
+function parseIndexParts(index) {
+    let parsed;
+    try {
+        parsed = JSON.parse(index);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(parsed)) {
+        return null;
+    }
+    const parts = [];
+    for (const item of parsed) {
+        if (typeof item === 'string') {
+            parts.push(item);
+            continue;
+        }
+        if (typeof item === 'number' || typeof item === 'boolean') {
+            parts.push(String(item));
+            continue;
+        }
+        return null;
+    }
+    return parts;
+}