zapo-js 0.1.1 → 0.2.0

package/dist/esm/media/WaMediaTransferClient.js

@@ -4,28 +4,98 @@ import { WaMediaCrypto } from './WaMediaCrypto.js';
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { EMPTY_BYTES, readAllBytes } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
+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 import(GOT_OPTIONAL_MODULE);
+        const module = asOptionalGotModule(loaded);
+        if (module) {
+            return module;
+        }
+        throw new Error('invalid got module export');
+    }
+    catch (error) {
+        const normalized = 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;
+    }
+}
 export class WaMediaTransferClient {
     constructor(options = {}) {
         this.logger = options.logger;
         this.defaultHosts = options.defaultHosts ?? DEFAULT_MEDIA_HOSTS;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? 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);
@@ -33,7 +103,9 @@ export class WaMediaTransferClient {
         if (!response.body) {
             return EMPTY_BYTES;
         }
-        return this.readAllBytesWithLimit(response.body, request.maxBytes);
+        return readAllBytes(response.body, {
+            maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+        });
     }
     async uploadStream(request) {
         const bodyIsBytes = request.body instanceof Uint8Array;
@@ -43,6 +115,8 @@ export 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', {
@@ -55,26 +129,28 @@ export 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', {
@@ -89,6 +165,8 @@ export 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,
@@ -109,7 +187,8 @@ export class WaMediaTransferClient {
             transfer,
             mediaKey,
             fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
+            fileEncSha256: metadata.fileEncSha256,
+            plaintextLength: metadata.plaintextLength
         };
     }
     async downloadAndDecrypt(request) {
@@ -119,7 +198,9 @@ export class WaMediaTransferClient {
         const decrypted = await this.downloadAndDecryptStream(request);
         try {
             const [plaintext] = await Promise.all([
-                this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes),
+                readAllBytes(decrypted.plaintext, {
+                    maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+                }),
                 decrypted.metadata
             ]);
             this.logger?.info('media encrypted download completed', {
@@ -155,13 +236,135 @@ export class WaMediaTransferClient {
         if (!response.body) {
             return EMPTY_BYTES;
         }
-        return this.readAllBytesWithLimit(response.body, maxBytes);
+        return 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
+                ? 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(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 {
@@ -170,14 +373,6 @@ export 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.encryptBytes(request.mediaType, mediaKey, request.plaintext);
@@ -186,7 +381,8 @@ export 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
             };
@@ -219,39 +415,26 @@ export 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 readAllBytes(stream, {
-            maxBytes: maxBytes ?? this.defaultMaxReadBytes
-        });
+        return resolved;
     }
     async fetchWithFallback(urls, timeoutMs, signal, send) {
         let lastError = null;
@@ -262,9 +445,15 @@ export 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
@@ -316,35 +505,6 @@ export class WaMediaTransferClient {
             }
         };
     }
-    toResponse(url, response) {
-        return {
-            url,
-            status: response.status,
-            ok: response.ok,
-            headers: this.headersToRecord(response.headers),
-            body: response.body
-                ? 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/esm/media/conn.js

@@ -16,12 +16,16 @@ export function parseMediaConnResponse(node, nowMs) {
         throw new Error('media_conn response has invalid ttl');
     }
     const expiresAtMs = ttlRaw >= 1000000000 ? ttlRaw * 1000 : nowMs + ttlRaw * 1000;
-    const hosts = getNodeChildrenByTag(mediaConnNode, 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 getNodeChildrenByTag(mediaConnNode, 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/esm/media/constants.js

@@ -1,4 +1,7 @@
-export const DEFAULT_MEDIA_HOSTS = ['mmg.whatsapp.net', 'mmg-fallback.whatsapp.net'];
+export const DEFAULT_MEDIA_HOSTS = Object.freeze([
+    'mmg.whatsapp.net',
+    'mmg-fallback.whatsapp.net'
+]);
 export const MEDIA_CONN_CACHE_GRACE_MS = 30000;
 export const MEDIA_HKDF_SIZE = 112;
 export const IV_SIZE = 16;
@@ -14,5 +17,6 @@ export const 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/esm/message/WaMessageClient.js

@@ -1,8 +1,9 @@
 import { describeAckNode, isAckOrReceiptNode, isNegativeAckNode, isRetryableNegativeAck } from './ack.js';
 import { WA_DEFAULTS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_NODE_TAGS } from '../protocol/constants.js';
-import { parseOptionalInt } from '../transport/stream/parse.js';
+import { buildReceiptNode } from '../transport/node/builders/global.js';
 import { delay } from '../util/async.js';
-import { toError } from '../util/primitives.js';
+import { parseOptionalInt, toError } from '../util/primitives.js';
+const WA_RETRYABLE_PUBLISH_ERROR_RE = /timeout|socket|connection|closed/i;
 class MessagePublishNackError extends Error {
     constructor(message, retryable) {
         super(message);
@@ -102,12 +103,7 @@ export 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 = {
@@ -117,6 +113,9 @@ export class WaMessageClient {
         if (input.id) {
             attrs.id = input.id;
         }
+        if (input.edit) {
+            attrs.edit = input.edit;
+        }
         if (input.category) {
             attrs.category = input.category;
         }
@@ -136,6 +135,9 @@ export class WaMessageClient {
             v: 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));
         }
@@ -153,6 +155,9 @@ export class WaMessageClient {
                 content: input.deviceIdentity
             });
         }
+        if (input.metaNode) {
+            content.push(input.metaNode);
+        }
         const node = {
             tag: WA_MESSAGE_TAGS.MESSAGE,
             attrs,
@@ -161,36 +166,29 @@ export class WaMessageClient {
         return node;
     }
     async sendReceipt(input) {
-        const attrs = {
+        const node = 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: 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;

package/dist/esm/message/ack.js

@@ -25,22 +25,22 @@ export function isRetryableNegativeAck(node) {
     return false;
 }
 export 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;
 }