zapo-js 0.1.1 → 0.2.0

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,28 +40,98 @@ 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, {
-                method: 'GET',
-                headers,
-                signal
-            })
+        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.transferRequest(url, {
+            method: 'GET',
+            headers,
+            signal
+        }, dispatcher, agent));
+        this.logger?.trace('media download stream response', {
+            url: result.url,
+            status: result.status
         });
+        return result;
     }
     async downloadBytes(request) {
         const response = await this.downloadStream(request);
@@ -36,7 +139,9 @@ class WaMediaTransferClient {
         if (!response.body) {
             return bytes_1.EMPTY_BYTES;
         }
-        return this.readAllBytesWithLimit(response.body, request.maxBytes);
+        return (0, bytes_1.readAllBytes)(response.body, {
+            maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+        });
     }
     async uploadStream(request) {
         const bodyIsBytes = request.body instanceof Uint8Array;
@@ -46,6 +151,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', {
@@ -58,26 +165,28 @@ class WaMediaTransferClient {
             timeoutMs,
             method
         });
-        return this.executeTransfer(uploadUrls, timeoutMs, request.signal, {
-            responseLog: 'media upload stream response',
-            send: async (url, signal) => {
-                if (bodyIsBytes) {
-                    return fetch(url, {
-                        method,
-                        headers,
-                        signal,
-                        body: request.body
-                    });
-                }
-                return fetch(url, {
+        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, async (url, signal) => {
+            if (bodyIsBytes) {
+                return this.transferRequest(url, {
                     method,
                     headers,
                     signal,
-                    body: request.body,
-                    duplex: 'half'
-                });
+                    body: request.body
+                }, dispatcher, agent);
             }
+            return this.transferRequest(url, {
+                method,
+                headers,
+                signal,
+                body: request.body,
+                duplex: 'half'
+            }, dispatcher, agent);
+        });
+        this.logger?.trace('media upload stream response', {
+            url: result.url,
+            status: result.status
         });
+        return result;
     }
     async uploadEncrypted(request) {
         this.logger?.info('media encrypted upload start', {
@@ -92,6 +201,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,
@@ -112,7 +223,8 @@ class WaMediaTransferClient {
             transfer,
             mediaKey,
             fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
+            fileEncSha256: metadata.fileEncSha256,
+            plaintextLength: metadata.plaintextLength
         };
     }
     async downloadAndDecrypt(request) {
@@ -122,7 +234,9 @@ class WaMediaTransferClient {
         const decrypted = await this.downloadAndDecryptStream(request);
         try {
             const [plaintext] = await Promise.all([
-                this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes),
+                (0, bytes_1.readAllBytes)(decrypted.plaintext, {
+                    maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+                }),
                 decrypted.metadata
             ]);
             this.logger?.info('media encrypted download completed', {
@@ -158,13 +272,135 @@ class WaMediaTransferClient {
         if (!response.body) {
             return bytes_1.EMPTY_BYTES;
         }
-        return this.readAllBytesWithLimit(response.body, maxBytes);
+        return (0, bytes_1.readAllBytes)(response.body, { maxBytes: maxBytes ?? this.defaultMaxReadBytes });
+    }
+    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: Object.fromEntries(response.headers.entries()),
+            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 {
@@ -173,14 +409,6 @@ class WaMediaTransferClient {
             timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs
         };
     }
-    async executeTransfer(urls, timeoutMs, signal, options) {
-        const result = await this.fetchWithFallback(urls, timeoutMs, signal, options.send);
-        this.logger?.trace(options.responseLog, {
-            url: result.url,
-            status: result.response.status
-        });
-        return this.toResponse(result.url, result.response);
-    }
     async prepareEncryptedUpload(request, mediaKey) {
         if (request.plaintext instanceof Uint8Array) {
             const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptBytes(request.mediaType, mediaKey, request.plaintext);
@@ -189,7 +417,8 @@ class WaMediaTransferClient {
                 contentLength: encrypted.ciphertextHmac.byteLength,
                 metadata: Promise.resolve({
                     fileSha256: encrypted.fileSha256,
-                    fileEncSha256: encrypted.fileEncSha256
+                    fileEncSha256: encrypted.fileEncSha256,
+                    plaintextLength: request.plaintext.byteLength
                 }),
                 cleanup: async () => undefined
             };
@@ -222,39 +451,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;
-    }
-    readAllBytesWithLimit(stream, maxBytes) {
-        return (0, bytes_1.readAllBytes)(stream, {
-            maxBytes: maxBytes ?? this.defaultMaxReadBytes
-        });
+        return resolved;
     }
     async fetchWithFallback(urls, timeoutMs, signal, send) {
         let lastError = null;
@@ -265,9 +481,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 +541,6 @@ 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()) {
-            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;
@@ -17,5 +20,6 @@ exports.MEDIA_UPLOAD_PATHS = Object.freeze({
     document: '/mms/document',
     sticker: '/mms/sticker',
     gif: '/mms/gif',
-    ptt: '/mms/ptt'
+    ptt: '/mms/ptt',
+    ptv: '/mms/video'
 });

package/dist/message/WaMessageClient.js

@@ -3,9 +3,10 @@ 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 global_1 = require("../transport/node/builders/global");
 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 +106,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 = {
@@ -120,6 +116,9 @@ class WaMessageClient {
         if (input.id) {
             attrs.id = input.id;
         }
+        if (input.edit) {
+            attrs.edit = input.edit;
+        }
         if (input.category) {
             attrs.category = input.category;
         }
@@ -139,6 +138,9 @@ class WaMessageClient {
             v: constants_1.WA_MESSAGE_TYPES.ENC_VERSION,
             type: input.encType
         };
+        if (input.mediatype) {
+            encAttrs.mediatype = input.mediatype;
+        }
         if (input.encCount !== undefined && input.encCount > 0) {
             encAttrs.count = String(Math.trunc(input.encCount));
         }
@@ -156,6 +158,9 @@ class WaMessageClient {
                 content: input.deviceIdentity
             });
         }
+        if (input.metaNode) {
+            content.push(input.metaNode);
+        }
         const node = {
             tag: constants_1.WA_MESSAGE_TAGS.MESSAGE,
             attrs,
@@ -164,36 +169,29 @@ class WaMessageClient {
         return node;
     }
     async sendReceipt(input) {
-        const attrs = {
+        const node = (0, global_1.buildReceiptNode)({
+            kind: 'outbound',
             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
+            type: input.type ?? 'read',
+            participant: input.participant,
+            recipient: input.recipient,
+            category: input.category,
+            from: input.from,
+            t: input.t,
+            peerParticipantPn: input.peerParticipantPn,
+            listIds: input.listIds,
+            content: input.content ? [...input.content] : undefined
         });
-        await this.sendNode({
-            tag: constants_1.WA_MESSAGE_TAGS.RECEIPT,
-            attrs
+        this.logger.debug('sending receipt node', {
+            to: node.attrs.to,
+            id: node.attrs.id,
+            type: node.attrs.type
         });
+        await this.sendNode(node);
     }
     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 +204,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)
         };
     }
 }