zapo-js 0.1.2 → 0.3.0

package/dist/esm/media/WaMediaTransferClient.js

@@ -1,10 +1,10 @@
-import { Readable } from 'node:stream';
+import http from 'node:http';
+import https from 'node:https';
 import { DEFAULT_MEDIA_HOSTS } from './constants.js';
 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 {};
@@ -15,56 +15,6 @@ function normalizeHeaderRecord(headers) {
     }
     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;
@@ -72,28 +22,23 @@ export class WaMediaTransferClient {
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.MEDIA_TIMEOUT_MS;
         this.defaultMaxReadBytes = options.defaultMaxReadBytes;
         this.defaultHeaders = normalizeHeaderRecord(options.defaultHeaders);
-        this.defaultUploadDispatcher = options.defaultUploadDispatcher;
-        this.defaultDownloadDispatcher = options.defaultDownloadDispatcher;
         this.defaultUploadAgent = options.defaultUploadAgent;
         this.defaultDownloadAgent = options.defaultDownloadAgent;
-        this.gotModulePromise = null;
+        this.skipMacVerification = options.skipMacVerification === true;
     }
     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) => this.transferRequest(url, {
-                method: 'GET',
-                headers,
-                signal
-            }, dispatcher, agent)
+        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.httpRequest(url, { method: 'GET', headers, signal }, 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);
@@ -101,7 +46,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;
@@ -111,7 +58,6 @@ 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) {
@@ -125,26 +71,12 @@ export class WaMediaTransferClient {
             timeoutMs,
             method
         });
-        return this.executeTransfer(uploadUrls, timeoutMs, request.signal, {
-            responseLog: 'media upload stream response',
-            send: async (url, signal) => {
-                if (bodyIsBytes) {
-                    return this.transferRequest(url, {
-                        method,
-                        headers,
-                        signal,
-                        body: request.body
-                    }, dispatcher, agent);
-                }
-                return this.transferRequest(url, {
-                    method,
-                    headers,
-                    signal,
-                    body: request.body,
-                    duplex: 'half'
-                }, dispatcher, agent);
-            }
+        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, (url, signal) => this.httpRequest(url, { method, headers, signal, body: request.body }, 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', {
@@ -159,7 +91,6 @@ export class WaMediaTransferClient {
                 directPath: request.directPath,
                 hosts: request.hosts,
                 headers: request.headers,
-                dispatcher: request.dispatcher,
                 agent: request.agent,
                 timeoutMs: request.timeoutMs,
                 signal: request.signal,
@@ -181,7 +112,8 @@ export class WaMediaTransferClient {
             transfer,
             mediaKey,
             fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
+            fileEncSha256: metadata.fileEncSha256,
+            plaintextLength: metadata.plaintextLength
         };
     }
     async downloadAndDecrypt(request) {
@@ -190,8 +122,12 @@ export class WaMediaTransferClient {
         });
         const decrypted = await this.downloadAndDecryptStream(request);
         try {
-            const plaintext = await this.readAllBytesWithLimit(decrypted.plaintext, request.maxBytes);
-            await decrypted.metadata;
+            const [plaintext] = await Promise.all([
+                readAllBytes(decrypted.plaintext, {
+                    maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+                }),
+                decrypted.metadata
+            ]);
             this.logger?.info('media encrypted download completed', {
                 byteLength: plaintext.byteLength
             });
@@ -210,7 +146,8 @@ export class WaMediaTransferClient {
             mediaType: request.mediaType,
             mediaKey: request.mediaKey,
             expectedFileSha256: request.fileSha256,
-            expectedFileEncSha256: request.fileEncSha256
+            expectedFileEncSha256: request.fileEncSha256,
+            skipMacVerification: this.skipMacVerification
         });
         decrypted.metadata.catch(() => undefined);
         this.logger?.debug('media encrypted download stream ready', {
@@ -225,121 +162,52 @@ export class WaMediaTransferClient {
         if (!response.body) {
             return EMPTY_BYTES;
         }
-        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);
+        return readAllBytes(response.body, { maxBytes: maxBytes ?? this.defaultMaxReadBytes });
     }
-    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 };
+    async httpRequest(url, init, agent) {
+        const parsed = new URL(url);
+        const transport = parsed.protocol === 'https:' ? https : http;
         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);
+            const req = transport.request(url, {
+                method: init.method ?? 'GET',
+                headers: init.headers,
+                signal: init.signal ?? undefined,
+                agent: agent ?? undefined
+            }, (res) => {
+                const status = res.statusCode ?? 500;
+                const headers = {};
+                for (const key in res.headers) {
+                    const value = res.headers[key];
+                    if (typeof value === 'string') {
+                        headers[key] = value;
+                    }
+                    else if (Array.isArray(value)) {
+                        headers[key] = value.join(', ');
+                    }
                 }
+                resolve({
+                    status,
+                    ok: status >= 200 && status < 300,
+                    headers,
+                    body: res,
+                    cancel: async () => {
+                        res.destroy();
+                    }
+                });
+            });
+            req.on('error', (error) => reject(toError(error)));
+            const body = init.body;
+            if (body instanceof Uint8Array) {
+                req.end(body);
             }
-        }
-        return {
-            status,
-            ok: status >= 200 && status < 300,
-            headers,
-            body: stream,
-            cancel: async () => {
-                stream.destroy();
+            else if (body) {
+                body.on('error', (err) => req.destroy(toError(err)));
+                body.pipe(req);
             }
-        };
+            else {
+                req.end();
+            }
+        });
     }
     resolveTransferRequest(request, extraHeaders) {
         const headers = { ...this.defaultHeaders };
@@ -362,14 +230,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.status
-        });
-        return result;
-    }
     async prepareEncryptedUpload(request, mediaKey) {
         if (request.plaintext instanceof Uint8Array) {
             const encrypted = await WaMediaCrypto.encryptBytes(request.mediaType, mediaKey, request.plaintext);
@@ -378,7 +238,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
             };
@@ -432,11 +293,6 @@ export class WaMediaTransferClient {
         }
         return resolved;
     }
-    readAllBytesWithLimit(stream, maxBytes) {
-        return readAllBytes(stream, {
-            maxBytes: maxBytes ?? this.defaultMaxReadBytes
-        });
-    }
     async fetchWithFallback(urls, timeoutMs, signal, send) {
         let lastError = null;
         for (let index = 0; index < urls.length; index += 1) {
@@ -506,13 +362,6 @@ export class WaMediaTransferClient {
             }
         };
     }
-    headersToRecord(headers) {
-        const output = {};
-        headers.forEach((value, key) => {
-            output[key] = value;
-        });
-        return output;
-    }
     async drainBody(body) {
         if (!body) {
             return;

package/dist/esm/media/constants.js

@@ -10,6 +10,8 @@ export const ENC_KEY_END = 48;
 export const MAC_KEY_START = 48;
 export const MAC_KEY_END = 80;
 export const HMAC_TRUNCATED_SIZE = 10;
+export const SIDECAR_CHUNK_SIZE = 65536;
+export const SIDECAR_HMAC_SIZE = 10;
 export const MEDIA_UPLOAD_PATHS = Object.freeze({
     image: '/mms/image',
     video: '/mms/video',
@@ -17,5 +19,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/media/processor.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/message/WaMessageClient.js

@@ -1,5 +1,6 @@
 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 { buildReceiptNode } from '../transport/node/builders/global.js';
 import { delay } from '../util/async.js';
 import { parseOptionalInt, toError } from '../util/primitives.js';
 const WA_RETRYABLE_PUBLISH_ERROR_RE = /timeout|socket|connection|closed/i;
@@ -112,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;
         }
@@ -131,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));
         }
@@ -148,6 +155,9 @@ export class WaMessageClient {
                 content: input.deviceIdentity
             });
         }
+        if (input.metaNode) {
+            content.push(input.metaNode);
+        }
         const node = {
             tag: WA_MESSAGE_TAGS.MESSAGE,
             attrs,
@@ -156,29 +166,26 @@ 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) {
         return WA_RETRYABLE_PUBLISH_ERROR_RE.test(error.message);

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

@@ -1,6 +1,8 @@
-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';
+import { aesGcmDecrypt, aesGcmEncrypt, importAesGcmKey, sha256 } from '../crypto/index.js';
+import { unwrapMessage } from './content.js';
+import { assertMessageSecret, createUseCaseSecret, WA_MESSAGE_SECRET_BYTES, WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret.js';
+import { proto } from '../proto.js';
+import { bytesToHex, 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 ||
@@ -41,6 +43,131 @@ export async function decryptAddonPayload(input) {
     const additionalData = resolveAddonAdditionalData(input);
     return aesGcmDecrypt(key, iv, toBytesView(input.ciphertext), additionalData);
 }
+export function identifyEncryptedAddon(message) {
+    const msg = unwrapMessage(message);
+    if (msg.encReactionMessage) {
+        const { targetMessageKey, encPayload, encIv } = msg.encReactionMessage;
+        if (targetMessageKey && encPayload && encIv) {
+            return {
+                kind: 'reaction',
+                targetMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.ENC_REACTION,
+                raw: message
+            };
+        }
+    }
+    if (msg.pollUpdateMessage) {
+        const { pollCreationMessageKey, vote } = msg.pollUpdateMessage;
+        if (pollCreationMessageKey && vote?.encPayload && vote.encIv) {
+            return {
+                kind: 'poll_vote',
+                targetMessageKey: pollCreationMessageKey,
+                encPayload: vote.encPayload,
+                encIv: vote.encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE,
+                raw: message
+            };
+        }
+    }
+    if (msg.encEventResponseMessage) {
+        const { eventCreationMessageKey, encPayload, encIv } = msg.encEventResponseMessage;
+        if (eventCreationMessageKey && encPayload && encIv) {
+            return {
+                kind: 'event_response',
+                targetMessageKey: eventCreationMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE,
+                raw: message
+            };
+        }
+    }
+    if (msg.encCommentMessage) {
+        const { targetMessageKey, encPayload, encIv } = msg.encCommentMessage;
+        if (targetMessageKey && encPayload && encIv) {
+            return {
+                kind: 'comment',
+                targetMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.ENC_COMMENT,
+                raw: message
+            };
+        }
+    }
+    return null;
+}
+export function decodeAddonPlaintext(kind, plaintext) {
+    switch (kind) {
+        case 'reaction':
+            return { kind, reaction: proto.Message.ReactionMessage.decode(plaintext) };
+        case 'poll_vote':
+            return {
+                kind,
+                pollVote: proto.Message.PollVoteMessage.decode(plaintext),
+                selectedOptionNames: null
+            };
+        case 'event_response':
+            return { kind, eventResponse: proto.Message.EventResponseMessage.decode(plaintext) };
+        case 'comment':
+            return { kind, comment: proto.Message.CommentMessage.decode(plaintext) };
+    }
+}
+export async function resolveParentMessageSecret(targetMessageId, messageSecretStore, messageStore) {
+    const cached = await messageSecretStore.get(targetMessageId);
+    if (cached)
+        return cached;
+    const record = await messageStore.getById(targetMessageId);
+    if (!record?.messageBytes)
+        return null;
+    try {
+        const decoded = proto.Message.decode(record.messageBytes);
+        const secret = decoded.messageContextInfo?.messageSecret;
+        if (!secret || secret.byteLength !== WA_MESSAGE_SECRET_BYTES)
+            return null;
+        return { secret, senderJid: record.senderJid ?? '' };
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolvePollOptionNames(selectedOptions, pollCreationMessageId, messageStore) {
+    const record = await messageStore.getById(pollCreationMessageId);
+    if (!record?.messageBytes)
+        return null;
+    let decoded;
+    try {
+        decoded = proto.Message.decode(record.messageBytes);
+    }
+    catch {
+        return null;
+    }
+    const pollMsg = unwrapMessage(decoded);
+    const options = pollMsg.pollCreationMessage?.options ??
+        pollMsg.pollCreationMessageV2?.options ??
+        pollMsg.pollCreationMessageV3?.options ??
+        pollMsg.pollCreationMessageV5?.options;
+    if (!options || options.length === 0)
+        return null;
+    const hashToName = new Map();
+    for (const option of options) {
+        if (!option.optionName)
+            continue;
+        const hash = await sha256(TEXT_ENCODER.encode(option.optionName));
+        hashToName.set(bytesToHex(hash), option.optionName);
+    }
+    const names = [];
+    for (const selected of selectedOptions) {
+        const hex = bytesToHex(selected);
+        const name = hashToName.get(hex);
+        if (!name)
+            return null;
+        names.push(name);
+    }
+    return names;
+}
 function assertAddonIv(iv) {
     const normalized = toBytesView(iv);
     if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {