zapo-js 0.1.0

package/dist/media/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEDIA_UPLOAD_PATHS = exports.HMAC_TRUNCATED_SIZE = exports.MAC_KEY_END = exports.MAC_KEY_START = exports.ENC_KEY_END = exports.ENC_KEY_START = exports.IV_SIZE = exports.MEDIA_HKDF_SIZE = exports.MEDIA_CONN_CACHE_GRACE_MS = exports.DEFAULT_MEDIA_HOSTS = void 0;
+exports.DEFAULT_MEDIA_HOSTS = ['mmg.whatsapp.net', 'mmg-fallback.whatsapp.net'];
+exports.MEDIA_CONN_CACHE_GRACE_MS = 30000;
+exports.MEDIA_HKDF_SIZE = 112;
+exports.IV_SIZE = 16;
+exports.ENC_KEY_START = 16;
+exports.ENC_KEY_END = 48;
+exports.MAC_KEY_START = 48;
+exports.MAC_KEY_END = 80;
+exports.HMAC_TRUNCATED_SIZE = 10;
+exports.MEDIA_UPLOAD_PATHS = Object.freeze({
+    image: '/mms/image',
+    video: '/mms/video',
+    audio: '/mms/audio',
+    document: '/mms/document',
+    sticker: '/mms/sticker',
+    gif: '/mms/gif',
+    ptt: '/mms/ptt'
+});

package/dist/media/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMediaCrypto = exports.parseMediaConnResponse = exports.WaMediaTransferClient = void 0;
+var WaMediaTransferClient_1 = require("./WaMediaTransferClient");
+Object.defineProperty(exports, "WaMediaTransferClient", { enumerable: true, get: function () { return WaMediaTransferClient_1.WaMediaTransferClient; } });
+var conn_1 = require("./conn");
+Object.defineProperty(exports, "parseMediaConnResponse", { enumerable: true, get: function () { return conn_1.parseMediaConnResponse; } });
+var WaMediaCrypto_1 = require("./WaMediaCrypto");
+Object.defineProperty(exports, "WaMediaCrypto", { enumerable: true, get: function () { return WaMediaCrypto_1.WaMediaCrypto; } });

package/dist/media/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/message/WaMessageClient.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaMessageClient = void 0;
+const ack_1 = require("./ack");
+const constants_1 = require("../protocol/constants");
+const parse_1 = require("../transport/stream/parse");
+const async_1 = require("../util/async");
+const primitives_1 = require("../util/primitives");
+class MessagePublishNackError extends Error {
+    constructor(message, retryable) {
+        super(message);
+        this.name = 'MessagePublishNackError';
+        this.retryable = retryable;
+    }
+}
+class WaMessageClient {
+    constructor(options) {
+        this.logger = options.logger;
+        this.sendNode = options.sendNode;
+        this.query = options.query;
+        this.defaultAckTimeoutMs = options.defaultAckTimeoutMs ?? constants_1.WA_DEFAULTS.MESSAGE_ACK_TIMEOUT_MS;
+        this.defaultMaxAttempts = options.defaultMaxAttempts ?? constants_1.WA_DEFAULTS.MESSAGE_MAX_ATTEMPTS;
+        this.defaultRetryDelayMs = options.defaultRetryDelayMs ?? constants_1.WA_DEFAULTS.MESSAGE_RETRY_DELAY_MS;
+    }
+    async publishNode(node, options = {}) {
+        if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
+            throw new Error(`invalid node tag for message publish: ${node.tag}`);
+        }
+        const ackTimeoutMs = options.ackTimeoutMs ?? this.defaultAckTimeoutMs;
+        const maxAttempts = options.maxAttempts ?? this.defaultMaxAttempts;
+        const retryDelayMs = options.retryDelayMs ?? this.defaultRetryDelayMs;
+        if (ackTimeoutMs < 1 || maxAttempts < 1 || retryDelayMs < 0) {
+            throw new Error('invalid message publish options');
+        }
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            try {
+                this.logger.debug('message publish attempt', {
+                    attempt,
+                    maxAttempts,
+                    to: node.attrs.to,
+                    type: node.attrs.type,
+                    id: node.attrs.id
+                });
+                const ackNode = await this.query(node, ackTimeoutMs);
+                const id = ackNode.attrs.id;
+                if (!id) {
+                    throw new Error('message publish ack node missing id');
+                }
+                if (!(0, ack_1.isAckOrReceiptNode)(ackNode)) {
+                    throw new Error(`unexpected publish response: ${(0, ack_1.describeAckNode)(ackNode)}`);
+                }
+                if ((0, ack_1.isNegativeAckNode)(ackNode)) {
+                    throw new MessagePublishNackError(`negative publish ack: ${(0, ack_1.describeAckNode)(ackNode)}`, (0, ack_1.isRetryableNegativeAck)(ackNode));
+                }
+                this.logger.info('message publish acknowledged', {
+                    id,
+                    tag: ackNode.tag,
+                    type: ackNode.attrs.type,
+                    phash: ackNode.attrs.phash,
+                    addressingMode: ackNode.attrs.addressing_mode,
+                    attempts: attempt
+                });
+                return {
+                    id,
+                    attempts: attempt,
+                    ackNode,
+                    ack: this.extractAckMetadata(ackNode)
+                };
+            }
+            catch (error) {
+                lastError = (0, primitives_1.toError)(error);
+                const nackRetryable = error instanceof MessagePublishNackError ? error.retryable : false;
+                const canRetry = attempt < maxAttempts &&
+                    (this.isRetryablePublishError(lastError) || nackRetryable);
+                this.logger.warn('message publish attempt failed', {
+                    attempt,
+                    maxAttempts,
+                    canRetry,
+                    nackRetryable,
+                    message: lastError.message
+                });
+                if (!canRetry) {
+                    throw lastError;
+                }
+                await (0, async_1.delay)(retryDelayMs * attempt);
+            }
+        }
+        throw lastError ?? new Error('message publish failed');
+    }
+    async publishEncrypted(input, options = {}) {
+        const node = this.buildEncryptedMessageNode(input);
+        return this.publishNode(node, options);
+    }
+    async sendMessageNode(node) {
+        if (node.tag !== constants_1.WA_MESSAGE_TAGS.MESSAGE) {
+            throw new Error(`invalid node tag for message send: ${node.tag}`);
+        }
+        this.logger.debug('message sent without waiting for ack', {
+            to: node.attrs.to,
+            type: node.attrs.type,
+            id: node.attrs.id
+        });
+        await this.sendNode(node);
+    }
+    async sendEncrypted(input) {
+        const node = this.buildEncryptedMessageNode(input);
+        this.logger.debug('encrypted message sent without waiting for ack', {
+            to: node.attrs.to,
+            type: node.attrs.type,
+            id: node.attrs.id
+        });
+        await this.sendNode(node);
+    }
+    buildEncryptedMessageNode(input) {
+        const attrs = {
+            to: input.to,
+            type: input.type ?? 'text'
+        };
+        if (input.id) {
+            attrs.id = input.id;
+        }
+        if (input.category) {
+            attrs.category = input.category;
+        }
+        if (input.pushPriority) {
+            attrs.push_priority = input.pushPriority;
+        }
+        if (input.participant) {
+            attrs.participant = input.participant;
+        }
+        if (input.addressingMode) {
+            attrs.addressing_mode = input.addressingMode;
+        }
+        if (input.deviceFanout) {
+            attrs.device_fanout = input.deviceFanout;
+        }
+        const encAttrs = {
+            v: constants_1.WA_MESSAGE_TYPES.ENC_VERSION,
+            type: input.encType
+        };
+        if (input.encCount !== undefined && input.encCount > 0) {
+            encAttrs.count = String(Math.trunc(input.encCount));
+        }
+        const content = [
+            {
+                tag: constants_1.WA_MESSAGE_TAGS.ENC,
+                attrs: encAttrs,
+                content: input.ciphertext
+            }
+        ];
+        if (input.deviceIdentity) {
+            content.push({
+                tag: constants_1.WA_NODE_TAGS.DEVICE_IDENTITY,
+                attrs: {},
+                content: input.deviceIdentity
+            });
+        }
+        const node = {
+            tag: constants_1.WA_MESSAGE_TAGS.MESSAGE,
+            attrs,
+            content
+        };
+        return node;
+    }
+    async sendReceipt(input) {
+        const attrs = {
+            to: input.to,
+            id: input.id,
+            type: input.type ?? 'read'
+        };
+        if (input.participant) {
+            attrs.participant = input.participant;
+        }
+        if (input.from) {
+            attrs.from = input.from;
+        }
+        if (input.t) {
+            attrs.t = input.t;
+        }
+        this.logger.debug('sending receipt node', {
+            to: attrs.to,
+            id: attrs.id,
+            type: attrs.type
+        });
+        await this.sendNode({
+            tag: constants_1.WA_MESSAGE_TAGS.RECEIPT,
+            attrs
+        });
+    }
+    isRetryablePublishError(error) {
+        const message = error.message.toLowerCase();
+        return (message.includes('timeout') ||
+            message.includes('socket') ||
+            message.includes('connection') ||
+            message.includes('closed'));
+    }
+    extractAckMetadata(ackNode) {
+        const addressingModeRaw = ackNode.attrs.addressing_mode;
+        const addressingMode = addressingModeRaw === 'pn' || addressingModeRaw === 'lid'
+            ? addressingModeRaw
+            : undefined;
+        return {
+            t: ackNode.attrs.t,
+            sync: ackNode.attrs.sync,
+            phash: ackNode.attrs.phash,
+            refreshLid: ackNode.attrs.refresh_lid === 'true',
+            addressingMode,
+            count: (0, parse_1.parseOptionalInt)(ackNode.attrs.count),
+            error: (0, parse_1.parseOptionalInt)(ackNode.attrs.error)
+        };
+    }
+}
+exports.WaMessageClient = WaMessageClient;

package/dist/message/ack.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAckOrReceiptNode = isAckOrReceiptNode;
+exports.isNegativeAckNode = isNegativeAckNode;
+exports.isRetryableNegativeAck = isRetryableNegativeAck;
+exports.describeAckNode = describeAckNode;
+const constants_1 = require("../protocol/constants");
+function isAckOrReceiptNode(node) {
+    return node.tag === constants_1.WA_MESSAGE_TAGS.ACK || node.tag === constants_1.WA_MESSAGE_TAGS.RECEIPT;
+}
+function isNegativeAckNode(node) {
+    if (node.tag === constants_1.WA_MESSAGE_TAGS.ERROR) {
+        return true;
+    }
+    if (node.tag !== constants_1.WA_MESSAGE_TAGS.ACK) {
+        return false;
+    }
+    const ackType = node.attrs.type;
+    const ackClass = node.attrs.class;
+    return (ackType === constants_1.WA_MESSAGE_TYPES.ACK_TYPE_ERROR || ackClass === constants_1.WA_MESSAGE_TYPES.ACK_CLASS_ERROR);
+}
+function isRetryableNegativeAck(node) {
+    const code = node.attrs.code;
+    if (code && constants_1.WA_RETRYABLE_ACK_CODES.includes(code)) {
+        return true;
+    }
+    const ackType = node.attrs.type;
+    if (ackType && (ackType === 'wait' || ackType === 'retry' || ackType === 'timeout')) {
+        return true;
+    }
+    return false;
+}
+function describeAckNode(node) {
+    const parts = [`tag=${node.tag}`];
+    const id = node.attrs.id;
+    const type = node.attrs.type;
+    const ackClass = node.attrs.class;
+    const code = node.attrs.code;
+    if (id) {
+        parts.push(`id=${id}`);
+    }
+    if (type) {
+        parts.push(`type=${type}`);
+    }
+    if (ackClass) {
+        parts.push(`class=${ackClass}`);
+    }
+    if (code) {
+        parts.push(`code=${code}`);
+    }
+    return parts.join(' ');
+}

package/dist/message/content.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSendMediaMessage = isSendMediaMessage;
+exports.resolveMessageTypeAttr = resolveMessageTypeAttr;
+function isSendMediaMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        'media' in content &&
+        'mimetype' in content);
+}
+function resolveMessageTypeAttr(message) {
+    if (message.reactionMessage) {
+        return 'reaction';
+    }
+    if (message.imageMessage ||
+        message.videoMessage ||
+        message.audioMessage ||
+        message.documentMessage ||
+        message.stickerMessage) {
+        return 'media';
+    }
+    return 'text';
+}

package/dist/message/device-sent.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapDeviceSentMessage = wrapDeviceSentMessage;
+exports.unwrapDeviceSentMessage = unwrapDeviceSentMessage;
+function wrapDeviceSentMessage(message, destinationJid) {
+    if (!destinationJid || destinationJid.trim().length === 0) {
+        throw new Error('device sent destinationJid must be a non-empty string');
+    }
+    if (message.deviceSentMessage) {
+        return message;
+    }
+    const rootContext = message.messageContextInfo ?? undefined;
+    if (!rootContext) {
+        return {
+            deviceSentMessage: {
+                destinationJid,
+                message
+            }
+        };
+    }
+    return {
+        messageContextInfo: {
+            ...rootContext
+        },
+        deviceSentMessage: {
+            destinationJid,
+            message: {
+                ...message,
+                messageContextInfo: undefined
+            }
+        }
+    };
+}
+function unwrapDeviceSentMessage(message) {
+    const nested = message.deviceSentMessage?.message ?? undefined;
+    if (!nested) {
+        return null;
+    }
+    const nestedContext = nested.messageContextInfo ?? undefined;
+    const rootContext = message.messageContextInfo ?? undefined;
+    const mergedContext = {
+        ...(nestedContext ?? {}),
+        messageSecret: nestedContext?.messageSecret ?? rootContext?.messageSecret,
+        messageAssociation: nestedContext?.messageAssociation ?? rootContext?.messageAssociation,
+        limitSharingV2: rootContext?.limitSharingV2 ?? nestedContext?.limitSharingV2,
+        threadId: nestedContext?.threadId ?? rootContext?.threadId ?? [],
+        botMetadata: nestedContext?.botMetadata ?? rootContext?.botMetadata
+    };
+    return {
+        ...nested,
+        messageContextInfo: mergedContext
+    };
+}