zapo-js 0.1.1 → 0.2.0

package/dist/esm/client/history-sync.js

@@ -1,8 +1,7 @@
 import { promisify } from 'node:util';
 import { unzip } from 'node:zlib';
 import { proto } from '../proto.js';
-import { decodeProtoBytes } from '../util/base64.js';
-import { toBytesView } from '../util/bytes.js';
+import { decodeProtoBytes, toBytesView } from '../util/bytes.js';
 import { longToNumber } from '../util/primitives.js';
 const unzipAsync = promisify(unzip);
 const HANDLED_SYNC_TYPES = new Set([
@@ -11,6 +10,7 @@ const HANDLED_SYNC_TYPES = new Set([
     proto.Message.HistorySyncType.FULL,
     proto.Message.HistorySyncType.PUSH_NAME
 ]);
+const HISTORY_SYNC_MAX_PENDING_WRITES = 1024;
 export async function processHistorySyncNotification(deps, notification) {
     const syncType = notification.syncType;
     if (syncType === null || syncType === undefined || !HANDLED_SYNC_TYPES.has(syncType)) {
@@ -28,15 +28,85 @@ export async function processHistorySyncNotification(deps, notification) {
         pushnames: historySync.pushnames.length
     });
     const nowMs = Date.now();
+    const pendingWrites = [];
+    for (const pn of historySync.pushnames) {
+        if (!pn.id) {
+            continue;
+        }
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistContactAsync({
+            jid: pn.id,
+            pushName: pn.pushname ?? undefined,
+            lastUpdatedMs: nowMs
+        });
+        if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+            await flushPendingWrites(pendingWrites);
+        }
+    }
     let messagesCount = 0;
-    const conversationPromises = [];
     for (const conversation of historySync.conversations) {
-        conversationPromises.push(persistConversation(deps, conversation, nowMs).then((count) => {
-            messagesCount += count;
-        }));
+        const threadJid = conversation.id;
+        if (!threadJid) {
+            deps.logger.debug('skipping history sync conversation without thread jid');
+            continue;
+        }
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistThreadAsync({
+            jid: threadJid,
+            name: conversation.name ?? undefined,
+            unreadCount: conversation.unreadCount ?? undefined,
+            archived: conversation.archived ?? undefined,
+            pinned: conversation.pinned ?? undefined,
+            muteEndMs: longToNumber(conversation.muteEndTime) || undefined,
+            markedAsUnread: conversation.markedAsUnread ?? undefined,
+            ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
+        });
+        if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+            await flushPendingWrites(pendingWrites);
+        }
+        for (const histMsg of conversation.messages ?? []) {
+            const webMsg = histMsg.message;
+            if (!webMsg?.key?.id) {
+                continue;
+            }
+            const timestampMs = longToNumber(webMsg.messageTimestamp) * 1000;
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
+                id: webMsg.key.id,
+                threadJid,
+                senderJid: webMsg.key.participant ?? undefined,
+                fromMe: webMsg.key.fromMe === true,
+                timestampMs: timestampMs || undefined,
+                messageBytes: webMsg.message
+                    ? proto.Message.encode(webMsg.message).finish()
+                    : undefined
+            });
+            if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+                await flushPendingWrites(pendingWrites);
+            }
+            messagesCount += 1;
+        }
+    }
+    if (deps.onPrivacyTokens) {
+        const tokenConversations = [];
+        for (const conversation of historySync.conversations) {
+            if (!conversation.id)
+                continue;
+            if (conversation.tcToken ||
+                conversation.tcTokenTimestamp ||
+                conversation.tcTokenSenderTimestamp) {
+                tokenConversations[tokenConversations.length] = {
+                    jid: conversation.id,
+                    tcToken: conversation.tcToken,
+                    tcTokenTimestamp: longToNumber(conversation.tcTokenTimestamp) || undefined,
+                    tcTokenSenderTimestamp: longToNumber(conversation.tcTokenSenderTimestamp) || undefined
+                };
+            }
+        }
+        if (tokenConversations.length > 0) {
+            pendingWrites[pendingWrites.length] = deps.onPrivacyTokens(tokenConversations);
+        }
+    }
+    if (deps.onNctSalt && historySync.nctSalt) {
+        pendingWrites[pendingWrites.length] = deps.onNctSalt(historySync.nctSalt);
     }
-    const pushnamePromise = persistPushnames(deps, historySync.pushnames, nowMs);
-    await Promise.all([...conversationPromises, pushnamePromise]);
     const event = {
         syncType,
         messagesCount,
@@ -45,8 +115,21 @@ export async function processHistorySyncNotification(deps, notification) {
         chunkOrder: historySync.chunkOrder ?? undefined,
         progress: historySync.progress ?? undefined
     };
+    await flushPendingWrites(pendingWrites);
     deps.emitEvent('history_sync_chunk', event);
 }
+async function flushPendingWrites(pendingWrites) {
+    if (pendingWrites.length === 0) {
+        return;
+    }
+    const pendingCount = pendingWrites.length;
+    const batch = new Array(pendingCount);
+    for (let index = 0; index < pendingCount; index += 1) {
+        batch[index] = pendingWrites[index];
+    }
+    pendingWrites.length = 0;
+    await Promise.all(batch);
+}
 async function downloadHistorySyncBlob(deps, notification) {
     if (notification.initialHistBootstrapInlinePayload) {
         return decodeProtoBytes(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');
@@ -65,55 +148,3 @@ async function downloadHistorySyncBlob(deps, notification) {
         fileEncSha256
     });
 }
-async function persistConversation(deps, conversation, _nowMs) {
-    const threadJid = conversation.id;
-    if (!threadJid) {
-        deps.logger.debug('skipping history sync conversation without thread jid');
-        return 0;
-    }
-    const messages = conversation.messages ?? [];
-    const messageRecords = [];
-    for (const histMsg of messages) {
-        const webMsg = histMsg.message;
-        if (!webMsg?.key?.id) {
-            continue;
-        }
-        const timestampMs = longToNumber(webMsg.messageTimestamp) * 1000;
-        const messageBytes = webMsg.message
-            ? proto.Message.encode(webMsg.message).finish()
-            : undefined;
-        messageRecords.push({
-            id: webMsg.key.id,
-            threadJid,
-            senderJid: webMsg.key.participant ?? undefined,
-            fromMe: webMsg.key.fromMe === true,
-            timestampMs: timestampMs || undefined,
-            messageBytes
-        });
-    }
-    const threadPromise = deps.threadStore.upsert({
-        jid: threadJid,
-        name: conversation.name ?? undefined,
-        unreadCount: conversation.unreadCount ?? undefined,
-        archived: conversation.archived ?? undefined,
-        pinned: conversation.pinned ?? undefined,
-        muteEndMs: longToNumber(conversation.muteEndTime) || undefined,
-        markedAsUnread: conversation.markedAsUnread ?? undefined,
-        ephemeralExpiration: conversation.ephemeralExpiration ?? undefined
-    });
-    const messagePromises = messageRecords.map((record) => deps.messageStore.upsert(record));
-    await Promise.all([threadPromise, ...messagePromises]);
-    return messageRecords.length;
-}
-async function persistPushnames(deps, pushnames, nowMs) {
-    if (pushnames.length === 0) {
-        return;
-    }
-    await Promise.all(pushnames
-        .filter((pn) => !!pn.id)
-        .map((pn) => deps.contactStore.upsert({
-        jid: pn.id,
-        pushName: pn.pushname ?? undefined,
-        lastUpdatedMs: nowMs
-    })));
-}

package/dist/esm/client/incoming.js

@@ -1,10 +1,16 @@
 import { parseGroupNotificationEvents } from './events/group.js';
-import { WA_NODE_TAGS, WA_NOTIFICATION_TYPES } from '../protocol/constants.js';
-import { buildInboundReceiptAckNode, buildInboundRetryReceiptAckNode } from '../transport/node/builders/message.js';
-import { buildNotificationAckNode } from '../transport/node/builders/pairing.js';
-import { getFirstNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
-import { parseOptionalInt } from '../transport/stream/parse.js';
-import { toError } from '../util/primitives.js';
+import { WA_DISCONNECT_REASONS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES } from '../protocol/constants.js';
+import { buildAckNode } from '../transport/node/builders/global.js';
+import { getFirstNodeChild, getNodeChildrenNonEmptyAttrValuesByTag } from '../transport/node/helpers.js';
+import { parseOptionalInt, toError } from '../util/primitives.js';
+const FAILURE_REASON_TO_DISCONNECT = {
+    401: WA_DISCONNECT_REASONS.FAILURE_NOT_AUTHORIZED,
+    403: WA_DISCONNECT_REASONS.FAILURE_LOCKED,
+    406: WA_DISCONNECT_REASONS.FAILURE_BANNED,
+    405: WA_DISCONNECT_REASONS.FAILURE_CLIENT_TOO_OLD,
+    409: WA_DISCONNECT_REASONS.FAILURE_BAD_USER_AGENT,
+    503: WA_DISCONNECT_REASONS.FAILURE_SERVICE_UNAVAILABLE
+};
 const LOGOUT_FAILURE_REASONS = new Set([401, 403, 406]);
 const DISCONNECT_FAILURE_REASONS = new Set([405, 409, 503]);
 const CORE_NOTIFICATION_TYPES = new Set([
@@ -31,6 +37,8 @@ const OUT_OF_SCOPE_NOTIFICATION_TYPES = new Set([
     'waffle',
     'hosted'
 ]);
+const NOTIFICATION_TYPES_WITH_PARTICIPANT_ACK = new Set(['mediaretry', 'psa']);
+const NOTIFICATION_TYPES_WITHOUT_TYPE_ACK = new Set(['encrypt', 'devices']);
 export function createIncomingBaseEvent(node) {
     return {
         rawNode: node,
@@ -64,7 +72,9 @@ function classifyNotificationType(notificationType) {
 }
 async function applyFailureAction(options, reason, clearStoredCredentials) {
     try {
-        await options.disconnect();
+        options.stopComms();
+        const disconnectReason = FAILURE_REASON_TO_DISCONNECT[reason] ?? WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER;
+        await options.disconnect(disconnectReason, clearStoredCredentials, reason);
         if (clearStoredCredentials) {
             await options.clearStoredCredentials();
         }
@@ -109,11 +119,19 @@ export function createIncomingReceiptHandler(options) {
                 await options.handleIncomingRetryReceipt(node);
             }
             else {
-                await sendSafeAck(options.logger, options.sendNode, buildInboundRetryReceiptAckNode(node));
+                await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+                    kind: 'receipt',
+                    node,
+                    retryType: true
+                }));
             }
             return true;
         }
-        await sendSafeAck(options.logger, options.sendNode, buildInboundReceiptAckNode(node));
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'receipt',
+            node,
+            includeParticipant: receiptType !== 'server-error'
+        }));
         return true;
     };
 }
@@ -139,49 +157,59 @@ export function createIncomingFailureHandler(options) {
 export function createIncomingNotificationHandler(options) {
     return async (node) => {
         const notificationType = node.attrs.type ?? '';
+        const includeParticipantInAck = NOTIFICATION_TYPES_WITH_PARTICIPANT_ACK.has(notificationType);
+        const includeTypeInAck = !NOTIFICATION_TYPES_WITHOUT_TYPE_ACK.has(notificationType);
         const classification = classifyNotificationType(notificationType);
         const firstChildTag = getFirstNodeChild(node)?.tag;
+        const baseEvent = createIncomingBaseEvent(node);
         const serverSyncCollections = notificationType === 'server_sync'
-            ? getNodeChildrenByTag(node, WA_NODE_TAGS.COLLECTION)
-                .map((collectionNode) => collectionNode.attrs.name)
-                .filter((name) => typeof name === 'string' && name.length > 0)
+            ? getNodeChildrenNonEmptyAttrValuesByTag(node, WA_NODE_TAGS.COLLECTION, 'name')
             : [];
+        let details;
+        if (firstChildTag || serverSyncCollections.length > 0) {
+            details = {};
+            if (firstChildTag) {
+                details.firstChildTag = firstChildTag;
+            }
+            if (serverSyncCollections.length > 0) {
+                details.collections = serverSyncCollections;
+            }
+        }
         options.emitIncomingNotification({
-            ...createIncomingBaseEvent(node),
+            ...baseEvent,
             notificationType,
             classification,
-            details: firstChildTag || serverSyncCollections.length > 0
-                ? {
-                    ...(firstChildTag ? { firstChildTag } : {}),
-                    ...(serverSyncCollections.length > 0
-                        ? { collections: serverSyncCollections }
-                        : {})
-                }
-                : undefined
+            details
         });
         if (classification === 'out_of_scope') {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${notificationType}.out_of_scope`
             });
         }
         else if (classification === 'unknown') {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${notificationType || 'unknown'}.not_supported`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, buildNotificationAckNode(node));
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'notification',
+            node,
+            includeParticipant: includeParticipantInAck,
+            includeType: includeTypeInAck
+        }));
         if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
+            const collectionsCsv = serverSyncCollections.join(',');
             if (!options.syncAppState) {
                 options.logger.warn('received server_sync notification without app-state sync runtime', {
-                    collections: serverSyncCollections.join(',')
+                    collections: collectionsCsv
                 });
                 return true;
             }
             void options.syncAppState().catch((error) => {
                 options.logger.warn('failed to sync app-state after server_sync notification', {
-                    collections: serverSyncCollections.join(','),
+                    collections: collectionsCsv,
                     message: toError(error).message
                 });
             });
@@ -194,6 +222,7 @@ export function createIncomingGroupNotificationHandler(options) {
         if (node.attrs.type !== WA_NOTIFICATION_TYPES.GROUP) {
             return false;
         }
+        const baseEvent = createIncomingBaseEvent(node);
         const parsed = parseGroupNotificationEvents(node);
         for (const event of parsed.events) {
             options.emitGroupEvent(event);
@@ -203,11 +232,15 @@ export function createIncomingGroupNotificationHandler(options) {
         }
         if (parsed.events.length === 0 && parsed.unhandled.length === 0) {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${WA_NOTIFICATION_TYPES.GROUP}.empty`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, buildNotificationAckNode(node));
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'notification',
+            node,
+            includeParticipant: true
+        }));
         return true;
     };
 }

package/dist/esm/client/mailbox.js

@@ -1,17 +1,20 @@
 import { proto } from '../proto.js';
 import { toError } from '../util/primitives.js';
-async function persistContacts(contactStore, event, nowMs) {
-    const candidateJids = new Set();
-    if (event.senderJid) {
-        candidateJids.add(event.senderJid);
+function persistContacts(writeBehind, event, nowMs) {
+    const senderJid = event.senderJid;
+    const participantJid = event.rawNode.attrs.participant;
+    if (!senderJid && !participantJid) {
+        return;
+    }
+    if (senderJid) {
+        writeBehind.persistContact({ jid: senderJid, lastUpdatedMs: nowMs });
     }
-    if (event.rawNode.attrs.participant) {
-        candidateJids.add(event.rawNode.attrs.participant);
+    if (participantJid && participantJid !== senderJid) {
+        writeBehind.persistContact({ jid: participantJid, lastUpdatedMs: nowMs });
     }
-    await Promise.all(Array.from(candidateJids, (jid) => contactStore.upsert({ jid, lastUpdatedMs: nowMs })));
 }
-export async function persistIncomingMailboxEntities(options) {
-    const { logger, contactStore, messageStore, event } = options;
+export function persistIncomingMailboxEntities(options) {
+    const { logger, writeBehind, event } = options;
     const { stanzaId, chatJid } = event;
     if (!stanzaId || !chatJid) {
         return;
@@ -21,20 +24,18 @@ export async function persistIncomingMailboxEntities(options) {
         const messageBytes = event.message
             ? proto.Message.encode(event.message).finish()
             : undefined;
-        await Promise.all([
-            messageStore.upsert({
-                id: stanzaId,
-                threadJid: chatJid,
-                senderJid: event.senderJid,
-                participantJid: event.rawNode.attrs.participant,
-                fromMe: false,
-                timestampMs: event.timestampSeconds === undefined ? undefined : event.timestampSeconds * 1000,
-                encType: event.encryptionType,
-                plaintext: event.plaintext,
-                messageBytes
-            }),
-            persistContacts(contactStore, event, nowMs)
-        ]);
+        writeBehind.persistMessage({
+            id: stanzaId,
+            threadJid: chatJid,
+            senderJid: event.senderJid,
+            participantJid: event.rawNode.attrs.participant,
+            fromMe: false,
+            timestampMs: event.timestampSeconds === undefined ? undefined : event.timestampSeconds * 1000,
+            encType: event.encryptionType,
+            plaintext: event.plaintext,
+            messageBytes
+        });
+        persistContacts(writeBehind, event, nowMs);
     }
     catch (error) {
         logger.warn('failed to persist incoming mailbox entities', {

package/dist/esm/client/messages.js

@@ -1,11 +1,11 @@
+import { createReadStream } from 'node:fs';
 import { parseMediaConnResponse } from '../media/conn.js';
 import { MEDIA_CONN_CACHE_GRACE_MS, MEDIA_UPLOAD_PATHS } from '../media/constants.js';
 import { WaMediaCrypto } from '../media/WaMediaCrypto.js';
 import { isSendMediaMessage } from '../message/content.js';
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { buildMediaConnIq } from '../transport/node/builders/media.js';
-import { bytesToBase64UrlSafe } from '../util/base64.js';
-import { TEXT_DECODER, toBytesView } from '../util/bytes.js';
+import { bytesToBase64UrlSafe, TEXT_DECODER, toBytesView } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export async function buildMediaMessageContent(options, content) {
     if (typeof content === 'string') {
@@ -31,15 +31,29 @@ export async function getMediaConn(options, forceRefresh = false) {
     options.setMediaConnCache(mediaConn);
     return mediaConn;
 }
+function resolveUploadType(content) {
+    if (content.type === 'video' && content.gifPlayback)
+        return 'gif';
+    if (content.type === 'audio' && content.ptt)
+        return 'ptt';
+    return content.type;
+}
+function isReadableStream(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'pipe' in value &&
+        typeof value.pipe === 'function');
+}
 async function buildMediaMessage(options, content) {
-    const mediaBytes = toBytesView(content.media);
-    const uploaded = await uploadMedia(options, content, mediaBytes);
+    const uploaded = isReadableStream(content.media)
+        ? await uploadMediaStream(options, content, content.media)
+        : await uploadMediaBytes(options, content, toBytesView(content.media));
     const mediaKeyTimestamp = Math.floor(Date.now() / 1000);
     const common = {
         url: uploaded.url,
         mimetype: content.mimetype,
         fileSha256: uploaded.fileSha256,
-        fileLength: mediaBytes.byteLength,
+        fileLength: uploaded.fileLength,
         mediaKey: uploaded.mediaKey,
         fileEncSha256: uploaded.fileEncSha256,
         directPath: uploaded.directPath,
@@ -67,6 +81,15 @@ async function buildMediaMessage(options, content) {
                     metadataUrl: uploaded.metadataUrl
                 }
             };
+        case 'ptv':
+            return {
+                ptvMessage: {
+                    ...common,
+                    seconds: content.seconds,
+                    width: content.width,
+                    height: content.height
+                }
+            };
         case 'audio':
             return {
                 audioMessage: {
@@ -93,24 +116,46 @@ async function buildMediaMessage(options, content) {
                 }
             };
         default:
-            throw new Error(`unsupported media type: ${content.type}`);
+            throw new Error(`unsupported media message type: ${String(content.type)}`);
+    }
+}
+function buildUploadUrl(host, uploadType, auth, fileEncSha256) {
+    const hashToken = bytesToBase64UrlSafe(fileEncSha256);
+    const uploadPath = MEDIA_UPLOAD_PATHS[uploadType];
+    if (!uploadPath) {
+        throw new Error(`unknown media upload type: ${String(uploadType)}`);
     }
+    return `https://${host}${uploadPath}/${hashToken}?auth=${encodeURIComponent(auth)}&token=${encodeURIComponent(hashToken)}`;
 }
-async function uploadMedia(options, content, mediaBytes) {
+function parseUploadResponse(body, status) {
+    if (status < 200 || status >= 300) {
+        throw new Error(`media upload failed with status ${status}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(TEXT_DECODER.decode(body));
+    }
+    catch (error) {
+        throw new Error(`media upload returned invalid json: ${toError(error).message}`);
+    }
+    if (!parsed.url || !parsed.direct_path) {
+        throw new Error('media upload response missing url/direct_path');
+    }
+    return {
+        url: parsed.url,
+        directPath: parsed.direct_path,
+        ...(parsed.metadata_url ? { metadataUrl: parsed.metadata_url } : {})
+    };
+}
+async function uploadMediaBytes(options, content, mediaBytes) {
+    const uploadType = resolveUploadType(content);
     const mediaKey = await WaMediaCrypto.generateMediaKey();
-    const uploadType = content.type === 'video' && content.gifPlayback
-        ? 'gif'
-        : content.type === 'audio' && content.ptt
-            ? 'ptt'
-            : content.type;
     const [encrypted, mediaConn] = await Promise.all([
         WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
         getMediaConn(options)
     ]);
     const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
-    const uploadPath = MEDIA_UPLOAD_PATHS[uploadType];
-    const hashToken = bytesToBase64UrlSafe(encrypted.fileEncSha256);
-    const uploadUrl = `https://${selectedHost}${uploadPath}/${hashToken}?auth=${encodeURIComponent(mediaConn.auth)}&token=${encodeURIComponent(hashToken)}`;
+    const uploadUrl = buildUploadUrl(selectedHost, uploadType, mediaConn.auth, encrypted.fileEncSha256);
     options.logger.debug('sending media upload request', {
         mediaType: content.type,
         uploadType,
@@ -123,26 +168,57 @@ async function uploadMedia(options, content, mediaBytes) {
         contentLength: encrypted.ciphertextHmac.byteLength,
         contentType: content.mimetype
     });
-    const uploadBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
-    if (!uploadResponse.ok) {
-        throw new Error(`media upload failed with status ${uploadResponse.status}`);
-    }
-    let parsedBody;
-    try {
-        parsedBody = JSON.parse(TEXT_DECODER.decode(uploadBody));
-    }
-    catch (error) {
-        throw new Error(`media upload returned invalid json: ${toError(error).message}`);
-    }
-    if (!parsedBody.url || !parsedBody.direct_path) {
-        throw new Error('media upload response missing url/direct_path');
-    }
+    const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+    const parsed = parseUploadResponse(responseBody, uploadResponse.status);
     return {
-        url: parsedBody.url,
-        directPath: parsedBody.direct_path,
+        ...parsed,
         mediaKey,
         fileSha256: encrypted.fileSha256,
         fileEncSha256: encrypted.fileEncSha256,
-        ...(parsedBody.metadata_url ? { metadataUrl: parsedBody.metadata_url } : {})
+        fileLength: mediaBytes.byteLength
     };
 }
+async function uploadMediaStream(options, content, stream) {
+    const uploadType = resolveUploadType(content);
+    const mediaKey = await WaMediaCrypto.generateMediaKey();
+    const encResult = await WaMediaCrypto.encryptToFile(uploadType, mediaKey, stream);
+    let readStream;
+    try {
+        const mediaConn = await getMediaConn(options);
+        const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ??
+            mediaConn.hosts[0].hostname;
+        const uploadUrl = buildUploadUrl(selectedHost, uploadType, mediaConn.auth, encResult.fileEncSha256);
+        options.logger.debug('sending media stream upload request', {
+            mediaType: content.type,
+            uploadType,
+            host: selectedHost,
+            encryptedSize: encResult.fileSize
+        });
+        readStream = createReadStream(encResult.filePath);
+        const uploadResponse = await options.mediaTransfer.uploadStream({
+            url: uploadUrl,
+            method: 'POST',
+            body: readStream,
+            contentLength: encResult.fileSize,
+            contentType: content.mimetype
+        });
+        const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+        const parsed = parseUploadResponse(responseBody, uploadResponse.status);
+        return {
+            ...parsed,
+            mediaKey,
+            fileSha256: encResult.fileSha256,
+            fileEncSha256: encResult.fileEncSha256,
+            fileLength: encResult.plaintextLength
+        };
+    }
+    finally {
+        if (readStream && !readStream.closed) {
+            await new Promise((resolve) => {
+                readStream.once('close', resolve);
+                readStream.destroy();
+            });
+        }
+        await WaMediaCrypto.cleanupEncryptedFile(encResult.filePath);
+    }
+}