zapo-js 0.1.2 → 0.2.0

package/dist/infra/perf/StoreLock.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreLock = void 0;
+class StoreLock {
+    constructor() {
+        this.chains = new Map();
+        this.closed = false;
+    }
+    run(key, task) {
+        return this.runInternal(key, task, true);
+    }
+    runInternal(key, task, rejectWhenClosed) {
+        if (this.closed) {
+            if (rejectWhenClosed) {
+                throw new Error('store lock is closed');
+            }
+        }
+        const previous = this.chains.get(key);
+        let current;
+        if (previous) {
+            current = previous.then(task);
+        }
+        else {
+            try {
+                current = task();
+            }
+            catch (error) {
+                current = Promise.reject(error);
+            }
+        }
+        const tracker = current.then(() => undefined, () => undefined);
+        this.chains.set(key, tracker);
+        void tracker.finally(() => {
+            if (this.chains.get(key) === tracker) {
+                this.chains.delete(key);
+            }
+        });
+        return current;
+    }
+    runMany(keys, task) {
+        if (this.closed) {
+            throw new Error('store lock is closed');
+        }
+        if (keys.length <= 1) {
+            return keys.length === 0 ? task() : this.runInternal(keys[0], task, false);
+        }
+        const ordered = new Array(keys.length);
+        for (let index = 0; index < keys.length; index += 1) {
+            ordered[index] = keys[index];
+        }
+        ordered.sort();
+        let uniqueCount = 1;
+        let previousKey = ordered[0];
+        for (let index = 1; index < ordered.length; index += 1) {
+            const key = ordered[index];
+            if (key === previousKey) {
+                continue;
+            }
+            ordered[uniqueCount] = key;
+            uniqueCount += 1;
+            previousKey = key;
+        }
+        const acquire = (index) => index >= uniqueCount
+            ? task()
+            : this.runInternal(ordered[index], () => Promise.resolve().then(() => acquire(index + 1)), false);
+        return acquire(0);
+    }
+    async shutdown() {
+        this.closed = true;
+        while (this.chains.size > 0) {
+            const pending = new Array(this.chains.size);
+            let pendingIndex = 0;
+            for (const chain of this.chains.values()) {
+                pending[pendingIndex] = chain;
+                pendingIndex += 1;
+            }
+            await Promise.allSettled(pending);
+        }
+    }
+}
+exports.StoreLock = StoreLock;

package/dist/media/WaMediaCrypto.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMediaCrypto = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_events_1 = require("node:events");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
 const node_stream_1 = require("node:stream");
 const hkdf_1 = require("../crypto/core/hkdf");
 const primitives_1 = require("../crypto/core/primitives");
@@ -80,17 +84,22 @@ class WaMediaCrypto {
         const metadata = pumpEncryption(plaintext, encrypted, keys);
         return { encrypted, metadata };
     }
-    static async decryptReadableToBytes(encrypted, options) {
-        const decrypted = await WaMediaCrypto.decryptReadable(encrypted, options);
-        const [plaintext, metadata] = await Promise.all([
-            (0, bytes_1.readAllBytes)(decrypted.plaintext),
-            decrypted.metadata
-        ]);
-        return {
-            plaintext,
-            fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
-        };
+    static async encryptToFile(mediaType, mediaKey, plaintext) {
+        const keys = await WaMediaCrypto.deriveKeys(mediaType, mediaKey);
+        const filePath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `zapo-enc-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const output = (0, node_fs_1.createWriteStream)(filePath);
+        try {
+            const metadata = await pumpEncryptionToWritable(plaintext, output, keys);
+            const fileSize = (await (0, promises_1.stat)(filePath)).size;
+            return { filePath, fileSize, ...metadata };
+        }
+        catch (error) {
+            await (0, promises_1.unlink)(filePath).catch(() => undefined);
+            throw error;
+        }
+    }
+    static async cleanupEncryptedFile(filePath) {
+        await (0, promises_1.unlink)(filePath).catch(() => undefined);
     }
     static async decryptReadable(encrypted, options) {
         const keys = await WaMediaCrypto.deriveKeys(options.mediaType, options.mediaKey);
@@ -112,6 +121,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
     const encHash = (0, node_crypto_1.createHash)('sha256');
     const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
     const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
     hmac.update(keys.iv);
     try {
         for await (const chunk of plaintext) {
@@ -119,6 +129,7 @@ async function pumpEncryption(plaintext, encrypted, keys) {
             if (plainChunk.byteLength === 0) {
                 continue;
             }
+            plaintextLength += plainChunk.byteLength;
             plainHash.update(plainChunk);
             const encryptedChunk = cipher.update(plainChunk);
             if (encryptedChunk.byteLength > 0) {
@@ -139,7 +150,8 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         encrypted.end();
         return {
             fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
-            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest())
+            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
+            plaintextLength
         };
     }
     catch (error) {
@@ -148,6 +160,76 @@ async function pumpEncryption(plaintext, encrypted, keys) {
         throw normalized;
     }
 }
+async function writeChunkToWritable(stream, chunk) {
+    if (chunk.byteLength === 0) {
+        return;
+    }
+    if (stream.write(chunk)) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const onDrain = () => {
+            stream.off('error', onError);
+            resolve();
+        };
+        const onError = (err) => {
+            stream.off('drain', onDrain);
+            reject(err);
+        };
+        stream.once('drain', onDrain);
+        stream.once('error', onError);
+    });
+}
+async function endWritable(stream) {
+    return new Promise((resolve, reject) => {
+        stream.on('error', reject);
+        stream.end(() => resolve());
+    });
+}
+async function pumpEncryptionToWritable(plaintext, output, keys) {
+    const plainHash = (0, node_crypto_1.createHash)('sha256');
+    const encHash = (0, node_crypto_1.createHash)('sha256');
+    const hmac = (0, node_crypto_1.createHmac)('sha256', keys.macKey);
+    const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', keys.encKey, keys.iv);
+    let plaintextLength = 0;
+    hmac.update(keys.iv);
+    try {
+        for await (const chunk of plaintext) {
+            const plainChunk = (0, bytes_1.toChunkBytes)(chunk);
+            if (plainChunk.byteLength === 0) {
+                continue;
+            }
+            plaintextLength += plainChunk.byteLength;
+            plainHash.update(plainChunk);
+            const encryptedChunk = cipher.update(plainChunk);
+            if (encryptedChunk.byteLength > 0) {
+                hmac.update(encryptedChunk);
+                encHash.update(encryptedChunk);
+                await writeChunkToWritable(output, encryptedChunk);
+            }
+        }
+        const encryptedFinal = cipher.final();
+        if (encryptedFinal.byteLength > 0) {
+            hmac.update(encryptedFinal);
+            encHash.update(encryptedFinal);
+            await writeChunkToWritable(output, encryptedFinal);
+        }
+        const signature = hmac.digest().subarray(0, constants_1.HMAC_TRUNCATED_SIZE);
+        encHash.update(signature);
+        await writeChunkToWritable(output, signature);
+        await endWritable(output);
+        return {
+            fileSha256: (0, bytes_1.toBytesView)(plainHash.digest()),
+            fileEncSha256: (0, bytes_1.toBytesView)(encHash.digest()),
+            plaintextLength
+        };
+    }
+    catch (error) {
+        const normalized = (0, primitives_2.toError)(error);
+        output.destroy(normalized);
+        throw normalized;
+    }
+}
 async function pumpDecryption(encrypted, plaintext, keys, options) {
     const plainHash = (0, node_crypto_1.createHash)('sha256');
     const encHash = (0, node_crypto_1.createHash)('sha256');

package/dist/media/WaMediaTransferClient.js

@@ -122,14 +122,16 @@ class WaMediaTransferClient {
             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.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);
@@ -137,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;
@@ -161,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 this.transferRequest(url, {
-                        method,
-                        headers,
-                        signal,
-                        body: request.body
-                    }, dispatcher, agent);
-                }
+        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', {
@@ -217,7 +223,8 @@ class WaMediaTransferClient {
             transfer,
             mediaKey,
             fileSha256: metadata.fileSha256,
-            fileEncSha256: metadata.fileEncSha256
+            fileEncSha256: metadata.fileEncSha256,
+            plaintextLength: metadata.plaintextLength
         };
     }
     async downloadAndDecrypt(request) {
@@ -226,8 +233,12 @@ 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([
+                (0, bytes_1.readAllBytes)(decrypted.plaintext, {
+                    maxBytes: request.maxBytes ?? this.defaultMaxReadBytes
+                }),
+                decrypted.metadata
+            ]);
             this.logger?.info('media encrypted download completed', {
                 byteLength: plaintext.byteLength
             });
@@ -261,7 +272,7 @@ 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) {
@@ -282,7 +293,7 @@ class WaMediaTransferClient {
         return {
             status: response.status,
             ok: response.ok,
-            headers: this.headersToRecord(response.headers),
+            headers: Object.fromEntries(response.headers.entries()),
             body: response.body
                 ? node_stream_1.Readable.fromWeb(response.body)
                 : null,
@@ -398,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.status
-        });
-        return result;
-    }
     async prepareEncryptedUpload(request, mediaKey) {
         if (request.plaintext instanceof Uint8Array) {
             const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptBytes(request.mediaType, mediaKey, request.plaintext);
@@ -414,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
             };
@@ -468,11 +472,6 @@ class WaMediaTransferClient {
         }
         return resolved;
     }
-    readAllBytesWithLimit(stream, maxBytes) {
-        return (0, bytes_1.readAllBytes)(stream, {
-            maxBytes: maxBytes ?? this.defaultMaxReadBytes
-        });
-    }
     async fetchWithFallback(urls, timeoutMs, signal, send) {
         let lastError = null;
         for (let index = 0; index < urls.length; index += 1) {
@@ -542,13 +541,6 @@ class WaMediaTransferClient {
             }
         };
     }
-    headersToRecord(headers) {
-        const output = {};
-        headers.forEach((value, key) => {
-            output[key] = value;
-        });
-        return output;
-    }
     async drainBody(body) {
         if (!body) {
             return;

package/dist/media/constants.js

@@ -20,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,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageClient = void 0;
 const ack_1 = require("./ack");
 const constants_1 = require("../protocol/constants");
+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;
@@ -115,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;
         }
@@ -134,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));
         }
@@ -151,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,
@@ -159,29 +169,26 @@ 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) {
         return WA_RETRYABLE_PUBLISH_ERROR_RE.test(error.message);