zapo-js 0.1.0 → 0.1.2

package/dist/esm/media/WaMediaTransferClient.js

@@ -4,27 +4,95 @@ 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, {
+            send: (url, signal) => this.transferRequest(url, {
                 method: 'GET',
                 headers,
                 signal
-            })
+            }, dispatcher, agent)
         });
     }
     async downloadBytes(request) {
@@ -43,6 +111,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', {
@@ -59,20 +129,20 @@ export 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);
             }
         });
     }
@@ -89,6 +159,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,
@@ -118,10 +190,8 @@ export 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
             });
@@ -157,11 +227,133 @@ export 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
+                ? 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 {
@@ -174,9 +366,9 @@ export 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) {
@@ -219,34 +411,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;
+        return resolved;
     }
     readAllBytesWithLimit(stream, maxBytes) {
         return readAllBytes(stream, {
@@ -262,9 +446,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 +506,13 @@ 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()) {
+        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/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;

package/dist/esm/message/WaMessageClient.js

@@ -1,8 +1,8 @@
 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 { 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 +102,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 = {
@@ -186,11 +181,7 @@ export 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;

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;
 }

package/dist/esm/message/addon-crypto.js

@@ -0,0 +1,59 @@
+import { aesGcmDecrypt, aesGcmEncrypt, importAesGcmKey } from '../crypto/index.js';
+import { assertMessageSecret, createUseCaseSecret, WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret.js';
+import { EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
+export function shouldUseAddonAdditionalData(modificationType) {
+    return (modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE ||
+        modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE);
+}
+export 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 TEXT_ENCODER.encode(`${stanzaId}\u0000${addOnSenderJid}`);
+}
+export async function encryptAddonPayload(input) {
+    const secret = await createUseCaseSecret({
+        messageSecret: assertMessageSecret(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await importAesGcmKey(secret, ['encrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return aesGcmEncrypt(key, iv, toBytesView(input.payload), additionalData);
+}
+export async function decryptAddonPayload(input) {
+    const secret = await createUseCaseSecret({
+        messageSecret: assertMessageSecret(input.messageSecret),
+        stanzaId: input.stanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const key = await importAesGcmKey(secret, ['decrypt']);
+    const iv = assertAddonIv(input.iv);
+    const additionalData = resolveAddonAdditionalData(input);
+    return aesGcmDecrypt(key, iv, toBytesView(input.ciphertext), additionalData);
+}
+function assertAddonIv(iv) {
+    const normalized = 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 toBytesView(input.additionalData);
+    }
+    if (!shouldUseAddonAdditionalData(input.modificationType)) {
+        return EMPTY_BYTES;
+    }
+    return buildAddonAdditionalData(input.stanzaId, input.modificationSender);
+}