zapo-js 0.1.1 → 0.1.2

package/dist/media/WaMediaTransferClient.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMediaTransferClient = void 0;
 const node_stream_1 = require("node:stream");
@@ -7,27 +40,95 @@ const WaMediaCrypto_1 = require("./WaMediaCrypto");
 const constants_2 = require("../protocol/constants");
 const bytes_1 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
+const GOT_OPTIONAL_MODULE = 'got';
+function normalizeHeaderRecord(headers) {
+    if (!headers) {
+        return {};
+    }
+    const normalized = {};
+    for (const key in headers) {
+        normalized[key.toLowerCase()] = headers[key];
+    }
+    return normalized;
+}
+function asOptionalGotModule(loaded) {
+    if (loaded && typeof loaded === 'object') {
+        const direct = loaded.stream;
+        if (typeof direct === 'function') {
+            return loaded;
+        }
+        const fallback = loaded.default;
+        if (fallback &&
+            typeof fallback === 'object' &&
+            'stream' in fallback &&
+            typeof fallback.stream === 'function') {
+            return fallback;
+        }
+        if (typeof fallback === 'function' && 'stream' in fallback) {
+            const maybeStream = fallback.stream;
+            if (typeof maybeStream === 'function') {
+                return fallback;
+            }
+        }
+    }
+    if (typeof loaded === 'function' && 'stream' in loaded) {
+        const maybeStream = loaded.stream;
+        if (typeof maybeStream === 'function') {
+            return loaded;
+        }
+    }
+    return null;
+}
+async function loadOptionalGotModule() {
+    try {
+        const loaded = await Promise.resolve(`${GOT_OPTIONAL_MODULE}`).then(s => __importStar(require(s)));
+        const module = asOptionalGotModule(loaded);
+        if (module) {
+            return module;
+        }
+        throw new Error('invalid got module export');
+    }
+    catch (error) {
+        const normalized = (0, primitives_1.toError)(error);
+        const code = normalized.code;
+        const message = normalized.message ?? '';
+        const isModuleNotFound = (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') &&
+            (message.includes(`'${GOT_OPTIONAL_MODULE}'`) ||
+                message.includes(`"${GOT_OPTIONAL_MODULE}"`));
+        if (isModuleNotFound) {
+            throw new Error('optional dependency "got" is not installed. Install with: npm i got');
+        }
+        throw normalized;
+    }
+}
 class WaMediaTransferClient {
     constructor(options = {}) {
         this.logger = options.logger;
         this.defaultHosts = options.defaultHosts ?? constants_1.DEFAULT_MEDIA_HOSTS;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_2.WA_DEFAULTS.MEDIA_TIMEOUT_MS;
         this.defaultMaxReadBytes = options.defaultMaxReadBytes;
-        this.defaultHeaders = options.defaultHeaders ?? {};
+        this.defaultHeaders = normalizeHeaderRecord(options.defaultHeaders);
+        this.defaultUploadDispatcher = options.defaultUploadDispatcher;
+        this.defaultDownloadDispatcher = options.defaultDownloadDispatcher;
+        this.defaultUploadAgent = options.defaultUploadAgent;
+        this.defaultDownloadAgent = options.defaultDownloadAgent;
+        this.gotModulePromise = null;
     }
     async downloadStream(request) {
         const { urls, headers, timeoutMs } = this.resolveTransferRequest(request);
+        const dispatcher = request.dispatcher ?? this.defaultDownloadDispatcher;
+        const agent = request.agent ?? this.defaultDownloadAgent;
         this.logger?.debug('media download stream start', {
             urls: urls.length,
             timeoutMs
         });
         return this.executeTransfer(urls, timeoutMs, request.signal, {
             responseLog: 'media download stream response',
-            send: (url, signal) => fetch(url, {
+            send: (url, signal) => this.transferRequest(url, {
                 method: 'GET',
                 headers,
                 signal
-            })
+            }, dispatcher, agent)
         });
     }
     async downloadBytes(request) {
@@ -46,6 +147,8 @@ class WaMediaTransferClient {
                 ? String(request.contentLength)
                 : undefined
         });
+        const dispatcher = request.dispatcher ?? this.defaultUploadDispatcher;
+        const agent = request.agent ?? this.defaultUploadAgent;
         const uploadUrls = bodyIsBytes ? urls : urls.slice(0, 1);
         if (!bodyIsBytes && urls.length > 1) {
             this.logger?.warn('upload stream fallback disabled for non-replayable body', {
@@ -62,20 +165,20 @@ class WaMediaTransferClient {
             responseLog: 'media upload stream response',
             send: async (url, signal) => {
                 if (bodyIsBytes) {
-                    return fetch(url, {
+                    return this.transferRequest(url, {
                         method,
                         headers,
                         signal,
                         body: request.body
-                    });
+                    }, dispatcher, agent);
                 }
-                return fetch(url, {
+                return this.transferRequest(url, {
                     method,
                     headers,
                     signal,
                     body: request.body,
                     duplex: 'half'
-                });
+                }, dispatcher, agent);
             }
         });
     }
@@ -92,6 +195,8 @@ class WaMediaTransferClient {
                 directPath: request.directPath,
                 hosts: request.hosts,
                 headers: request.headers,
+                dispatcher: request.dispatcher,
+                agent: request.agent,
                 timeoutMs: request.timeoutMs,
                 signal: request.signal,
                 method: request.method,
@@ -121,10 +226,8 @@ class WaMediaTransferClient {
         });
         const decrypted = await this.downloadAndDecryptStream(request);
         try {
-            const [plaintext] = await Promise.all([
-                this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes),
-                decrypted.metadata
-            ]);
+            const plaintext = await this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes);
+            await decrypted.metadata;
             this.logger?.info('media encrypted download completed', {
                 byteLength: plaintext.byteLength
             });
@@ -160,11 +263,133 @@ class WaMediaTransferClient {
         }
         return this.readAllBytesWithLimit(response.body, maxBytes);
     }
+    async transferRequest(url, init, dispatcher, agent) {
+        if (agent) {
+            return this.gotWithAgent(url, init, agent);
+        }
+        return this.fetchWithDispatcher(url, init, dispatcher);
+    }
+    async fetchWithDispatcher(url, init, dispatcher) {
+        const response = !dispatcher
+            ? await fetch(url, init)
+            : await fetch(url, {
+                ...init,
+                dispatcher
+            });
+        return this.toFetchTransferResponse(response);
+    }
+    toFetchTransferResponse(response) {
+        return {
+            status: response.status,
+            ok: response.ok,
+            headers: this.headersToRecord(response.headers),
+            body: response.body
+                ? node_stream_1.Readable.fromWeb(response.body)
+                : null,
+            cancel: async () => {
+                if (!response.body) {
+                    return;
+                }
+                try {
+                    await response.body.cancel();
+                }
+                catch {
+                    // ignore cancel errors from remote resets
+                }
+            }
+        };
+    }
+    async gotWithAgent(url, init, agent) {
+        const got = await this.loadGotModule();
+        const urlObj = new URL(url);
+        const gotAgent = urlObj.protocol === 'http:'
+            ? { http: agent }
+            : urlObj.protocol === 'https:'
+                ? { https: agent }
+                : { http: agent, https: agent };
+        return new Promise((resolve, reject) => {
+            const request = got.stream(url, {
+                method: init.method,
+                headers: (init.headers ?? {}),
+                body: init.body,
+                signal: init.signal,
+                throwHttpErrors: false,
+                retry: { limit: 0 },
+                agent: gotAgent
+            });
+            const onError = (error) => {
+                request.off('response', onResponse);
+                reject((0, primitives_1.toError)(error));
+            };
+            const onResponse = (incoming) => {
+                request.off('error', onError);
+                resolve(this.toGotTransferResponse(incoming));
+            };
+            request.once('error', onError);
+            request.once('response', onResponse);
+        });
+    }
+    async loadGotModule() {
+        if (!this.gotModulePromise) {
+            this.gotModulePromise = loadOptionalGotModule().catch((error) => {
+                this.gotModulePromise = null;
+                throw error;
+            });
+        }
+        return this.gotModulePromise;
+    }
+    toGotTransferResponse(incoming) {
+        if (!incoming || typeof incoming !== 'object') {
+            throw new Error('invalid got response object');
+        }
+        const stream = incoming;
+        const status = typeof stream.statusCode === 'number' &&
+            Number.isFinite(stream.statusCode) &&
+            stream.statusCode >= 100 &&
+            stream.statusCode <= 599
+            ? stream.statusCode
+            : 500;
+        const headers = {};
+        if (stream.headers && typeof stream.headers === 'object') {
+            const input = stream.headers;
+            for (const key in input) {
+                const value = input[key];
+                if (typeof value === 'string') {
+                    headers[key] = value;
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    headers[key] = value.join(', ');
+                    continue;
+                }
+                if (value !== undefined && value !== null) {
+                    headers[key] = String(value);
+                }
+            }
+        }
+        return {
+            status,
+            ok: status >= 200 && status < 300,
+            headers,
+            body: stream,
+            cancel: async () => {
+                stream.destroy();
+            }
+        };
+    }
     resolveTransferRequest(request, extraHeaders) {
-        const headers = this.mergeHeaders(request.headers);
-        for (const [key, value] of Object.entries(extraHeaders ?? {})) {
-            if (value !== undefined) {
-                headers[key.toLowerCase()] = value;
+        const headers = { ...this.defaultHeaders };
+        if (request.headers) {
+            for (const key in request.headers) {
+                headers[key.toLowerCase()] = request.headers[key];
+            }
+        }
+        if (extraHeaders) {
+            for (const key in extraHeaders) {
+                const value = extraHeaders[key];
+                if (value !== undefined) {
+                    headers[key.toLowerCase()] = value;
+                }
             }
         }
         return {
@@ -177,9 +402,9 @@ class WaMediaTransferClient {
         const result = await this.fetchWithFallback(urls, timeoutMs, signal, options.send);
         this.logger?.trace(options.responseLog, {
             url: result.url,
-            status: result.response.status
+            status: result.status
         });
-        return this.toResponse(result.url, result.response);
+        return result;
     }
     async prepareEncryptedUpload(request, mediaKey) {
         if (request.plaintext instanceof Uint8Array) {
@@ -222,34 +447,26 @@ class WaMediaTransferClient {
     }
     resolveUrls(url, directPath, hosts) {
         const resolved = [];
-        if (url) {
+        if (url && resolved.indexOf(url) === -1)
             resolved.push(url);
-        }
         if (directPath) {
             if (directPath.startsWith('https://') || directPath.startsWith('http://')) {
-                resolved.push(directPath);
+                if (resolved.indexOf(directPath) === -1)
+                    resolved.push(directPath);
             }
             else {
                 const normalizedPath = directPath.startsWith('/') ? directPath : `/${directPath}`;
                 for (const host of hosts ?? this.defaultHosts) {
-                    resolved.push(`https://${host}${normalizedPath}`);
+                    const candidate = `https://${host}${normalizedPath}`;
+                    if (resolved.indexOf(candidate) === -1)
+                        resolved.push(candidate);
                 }
             }
         }
         if (resolved.length === 0) {
             throw new Error('missing transfer url/directPath');
         }
-        return Array.from(new Set(resolved));
-    }
-    mergeHeaders(headers) {
-        const merged = {};
-        for (const [key, value] of Object.entries(this.defaultHeaders)) {
-            merged[key.toLowerCase()] = value;
-        }
-        for (const [key, value] of Object.entries(headers ?? {})) {
-            merged[key.toLowerCase()] = value;
-        }
-        return merged;
+        return resolved;
     }
     readAllBytesWithLimit(stream, maxBytes) {
         return (0, bytes_1.readAllBytes)(stream, {
@@ -265,9 +482,15 @@ class WaMediaTransferClient {
                 const response = await send(url, abort.signal);
                 const shouldFallback = response.status >= 500 && index < urls.length - 1;
                 if (!shouldFallback) {
-                    return { url, response };
+                    return {
+                        url,
+                        status: response.status,
+                        ok: response.ok,
+                        headers: response.headers,
+                        body: response.body
+                    };
                 }
-                await this.cancelWebBody(response.body);
+                await response.cancel();
                 this.logger?.warn('transfer fallback to next host', {
                     url,
                     status: response.status
@@ -319,35 +542,13 @@ class WaMediaTransferClient {
             }
         };
     }
-    toResponse(url, response) {
-        return {
-            url,
-            status: response.status,
-            ok: response.ok,
-            headers: this.headersToRecord(response.headers),
-            body: response.body
-                ? node_stream_1.Readable.fromWeb(response.body)
-                : null
-        };
-    }
     headersToRecord(headers) {
         const output = {};
-        for (const [key, value] of headers.entries()) {
+        headers.forEach((value, key) => {
             output[key] = value;
-        }
+        });
         return output;
     }
-    async cancelWebBody(body) {
-        if (!body) {
-            return;
-        }
-        try {
-            await body.cancel();
-        }
-        catch {
-            // ignore cancel errors from remote resets
-        }
-    }
     async drainBody(body) {
         if (!body) {
             return;

package/dist/media/conn.js

@@ -19,12 +19,16 @@ function parseMediaConnResponse(node, nowMs) {
         throw new Error('media_conn response has invalid ttl');
     }
     const expiresAtMs = ttlRaw >= 1000000000 ? ttlRaw * 1000 : nowMs + ttlRaw * 1000;
-    const hosts = (0, helpers_1.getNodeChildrenByTag)(mediaConnNode, constants_1.WA_NODE_TAGS.HOST)
-        .map((host) => ({
-        hostname: host.attrs.hostname ?? '',
-        isFallback: host.attrs.type === 'fallback'
-    }))
-        .filter((host) => host.hostname.length > 0);
+    const hosts = [];
+    for (const host of (0, helpers_1.getNodeChildrenByTag)(mediaConnNode, constants_1.WA_NODE_TAGS.HOST)) {
+        const hostname = host.attrs.hostname;
+        if (hostname) {
+            hosts.push({
+                hostname,
+                isFallback: host.attrs.type === 'fallback'
+            });
+        }
+    }
     if (hosts.length === 0) {
         throw new Error('media_conn response contains no hosts');
     }

package/dist/media/constants.js

@@ -1,7 +1,10 @@
 "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.DEFAULT_MEDIA_HOSTS = Object.freeze([
+    'mmg.whatsapp.net',
+    'mmg-fallback.whatsapp.net'
+]);
 exports.MEDIA_CONN_CACHE_GRACE_MS = 30000;
 exports.MEDIA_HKDF_SIZE = 112;
 exports.IV_SIZE = 16;

package/dist/message/WaMessageClient.js

@@ -3,9 +3,9 @@ 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");
+const WA_RETRYABLE_PUBLISH_ERROR_RE = /timeout|socket|connection|closed/i;
 class MessagePublishNackError extends Error {
     constructor(message, retryable) {
         super(message);
@@ -105,12 +105,7 @@ class WaMessageClient {
     }
     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);
+        await this.sendMessageNode(node);
     }
     buildEncryptedMessageNode(input) {
         const attrs = {
@@ -189,11 +184,7 @@ class WaMessageClient {
         });
     }
     isRetryablePublishError(error) {
-        const message = error.message.toLowerCase();
-        return (message.includes('timeout') ||
-            message.includes('socket') ||
-            message.includes('connection') ||
-            message.includes('closed'));
+        return WA_RETRYABLE_PUBLISH_ERROR_RE.test(error.message);
     }
     extractAckMetadata(ackNode) {
         const addressingModeRaw = ackNode.attrs.addressing_mode;
@@ -206,8 +197,8 @@ class WaMessageClient {
             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)
+            count: (0, primitives_1.parseOptionalInt)(ackNode.attrs.count),
+            error: (0, primitives_1.parseOptionalInt)(ackNode.attrs.error)
         };
     }
 }

package/dist/message/ack.js

@@ -31,22 +31,22 @@ function isRetryableNegativeAck(node) {
     return false;
 }
 function describeAckNode(node) {
-    const parts = [`tag=${node.tag}`];
+    let description = `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}`);
+        description += ` id=${id}`;
     }
     if (type) {
-        parts.push(`type=${type}`);
+        description += ` type=${type}`;
     }
     if (ackClass) {
-        parts.push(`class=${ackClass}`);
+        description += ` class=${ackClass}`;
     }
     if (code) {
-        parts.push(`code=${code}`);
+        description += ` code=${code}`;
     }
-    return parts.join(' ');
+    return description;
 }

package/dist/message/addon-crypto.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseAddonAdditionalData = shouldUseAddonAdditionalData;
+exports.buildAddonAdditionalData = buildAddonAdditionalData;
+exports.encryptAddonPayload = encryptAddonPayload;
+exports.decryptAddonPayload = decryptAddonPayload;
+const _crypto_1 = require("../crypto/index.js");
+const use_case_secret_1 = require("./use-case-secret");
+const bytes_1 = require("../util/bytes");
+const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
+function shouldUseAddonAdditionalData(modificationType) {
+    return (modificationType === use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE ||
+        modificationType === use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE);
+}
+function buildAddonAdditionalData(stanzaId, addOnSenderJid) {
+    if (!stanzaId.trim()) {
+        throw new Error('stanza id must be a non-empty string');
+    }
+    if (!addOnSenderJid.trim()) {
+        throw new Error('addon sender jid must be a non-empty string');
+    }
+    return bytes_1.TEXT_ENCODER.encode(`${stanzaId}\u0000${addOnSenderJid}`);
+}
+async function encryptAddonPayload(input) {
+    const secret = await (0, use_case_secret_1.createUseCaseSecret)({
+        messageSecret: (0, use_case_secret_1.assertMessageSecret)(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await (0, _crypto_1.importAesGcmKey)(secret, ['encrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return (0, _crypto_1.aesGcmEncrypt)(key, iv, (0, bytes_1.toBytesView)(input.payload), additionalData);
+}
+async function decryptAddonPayload(input) {
+    const secret = await (0, use_case_secret_1.createUseCaseSecret)({
+        messageSecret: (0, use_case_secret_1.assertMessageSecret)(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await (0, _crypto_1.importAesGcmKey)(secret, ['decrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return (0, _crypto_1.aesGcmDecrypt)(key, iv, (0, bytes_1.toBytesView)(input.ciphertext), additionalData);
+}
+function assertAddonIv(iv) {
+    const normalized = (0, bytes_1.toBytesView)(iv);
+    if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {
+        throw new Error(`addon iv must be ${WA_ADDON_ENCRYPTION_NONCE_BYTES} bytes (got ${normalized.byteLength})`);
+    }
+    return normalized;
+}
+function resolveAddonAdditionalData(input) {
+    if (input.additionalData) {
+        return (0, bytes_1.toBytesView)(input.additionalData);
+    }
+    if (!shouldUseAddonAdditionalData(input.modificationType)) {
+        return bytes_1.EMPTY_BYTES;
+    }
+    return buildAddonAdditionalData(input.stanzaId, input.modificationSender);
+}