zapo-js 0.1.2 → 0.2.0

package/dist/esm/client/events/devices.js

@@ -0,0 +1,68 @@
+import { parseSignalAddressFromJid } from '../../protocol/jid.js';
+import { findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+export const DEVICE_NOTIFICATION_ACTIONS = Object.freeze({
+    ADD: 'add',
+    REMOVE: 'remove',
+    UPDATE: 'update'
+});
+export function parseDeviceNotification(node) {
+    const stanzaId = node.attrs.id;
+    const fromJid = node.attrs.from;
+    if (!stanzaId || !fromJid) {
+        return null;
+    }
+    let action;
+    let actionNode;
+    if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE)) {
+        action = DEVICE_NOTIFICATION_ACTIONS.REMOVE;
+        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+    }
+    else if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD)) {
+        action = DEVICE_NOTIFICATION_ACTIONS.ADD;
+        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.ADD);
+    }
+    else if (findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE)) {
+        action = DEVICE_NOTIFICATION_ACTIONS.UPDATE;
+        actionNode = findNodeChild(node, DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+    }
+    else {
+        return null;
+    }
+    const devices = [];
+    if (action !== DEVICE_NOTIFICATION_ACTIONS.UPDATE && actionNode) {
+        const deviceNodes = getNodeChildrenByTag(actionNode, 'device');
+        for (let index = 0; index < deviceNodes.length; index += 1) {
+            const deviceNode = deviceNodes[index];
+            const jidAttr = deviceNode.attrs.jid;
+            if (!jidAttr) {
+                continue;
+            }
+            let deviceId;
+            try {
+                deviceId = parseSignalAddressFromJid(jidAttr).device;
+            }
+            catch {
+                continue;
+            }
+            const keyIndexAttr = deviceNode.attrs['key-index'];
+            const parsedKeyIndex = keyIndexAttr === undefined ? null : Number.parseInt(keyIndexAttr, 10);
+            const keyIndex = parsedKeyIndex !== null &&
+                Number.isSafeInteger(parsedKeyIndex) &&
+                parsedKeyIndex >= 0
+                ? parsedKeyIndex
+                : null;
+            devices[devices.length] = {
+                deviceId,
+                keyIndex
+            };
+        }
+    }
+    return {
+        action,
+        stanzaId,
+        fromJid,
+        lid: node.attrs.lid,
+        hash: action === DEVICE_NOTIFICATION_ACTIONS.UPDATE ? actionNode?.attrs.hash : undefined,
+        devices
+    };
+}

package/dist/esm/client/events/group.js

@@ -1,3 +1,4 @@
+import { createUnhandledIncomingNodeEvent } from '../incoming.js';
 import { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from '../../protocol/constants.js';
 import { WA_NODE_TAGS } from '../../protocol/nodes.js';
 import { findNodeChild, getNodeChildren, getNodeChildrenByTag } from '../../transport/node/helpers.js';
@@ -99,15 +100,6 @@ function createBaseGroupEvent(notificationNode, actionNode) {
         timestampSeconds: parseOptionalInt(notificationNode.attrs.t)
     };
 }
-function createUnhandledStanzaEvent(notificationNode, reason) {
-    return {
-        rawNode: notificationNode,
-        stanzaId: notificationNode.attrs.id,
-        chatJid: notificationNode.attrs.from,
-        stanzaType: notificationNode.attrs.type,
-        reason
-    };
-}
 function parseCreateGroupAction(notificationNode, actionNode) {
     const groupNode = findNodeChild(actionNode, WA_NODE_TAGS.GROUP);
     if (!groupNode) {
@@ -413,13 +405,13 @@ export function parseGroupNotificationEvents(notificationNode) {
         try {
             const parsedEvent = parseGroupActionNode(notificationNode, actionNode);
             if (!parsedEvent) {
-                unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
+                unhandled.push(createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
                 continue;
             }
             events.push(parsedEvent);
         }
         catch {
-            unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
+            unhandled.push(createUnhandledIncomingNodeEvent(notificationNode, `notification.${WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
         }
     }
     return {

package/dist/esm/client/events/identity.js

@@ -0,0 +1,19 @@
+import { getFirstNodeChild } from '../../transport/node/helpers.js';
+export function parseIdentityChangeNotification(node) {
+    const child = getFirstNodeChild(node);
+    if (!child || child.tag !== 'identity') {
+        return null;
+    }
+    const fromJid = node.attrs.from;
+    const stanzaId = node.attrs.id;
+    if (!fromJid || !stanzaId) {
+        return null;
+    }
+    return {
+        fromJid,
+        stanzaId,
+        displayName: node.attrs.display_name,
+        lid: node.attrs.lid,
+        offline: node.attrs.offline
+    };
+}

package/dist/esm/client/events/privacy-token.js

@@ -0,0 +1,36 @@
+import { WA_PRIVACY_TOKEN_TAGS } from '../../protocol/privacy-token.js';
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { toBytesView } from '../../util/bytes.js';
+import { asNumber } from '../../util/coercion.js';
+export function parsePrivacyTokenNotification(node) {
+    const tokensNode = findNodeChild(node, WA_PRIVACY_TOKEN_TAGS.TOKENS);
+    if (!tokensNode) {
+        return [];
+    }
+    const children = getNodeChildren(tokensNode);
+    const result = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== WA_PRIVACY_TOKEN_TAGS.TOKEN) {
+            continue;
+        }
+        const type = child.attrs.type;
+        if (!type) {
+            continue;
+        }
+        const rawTimestamp = child.attrs.t;
+        if (!rawTimestamp) {
+            continue;
+        }
+        const content = child.content;
+        if (!(content instanceof Uint8Array)) {
+            continue;
+        }
+        result[result.length] = {
+            type,
+            tokenBytes: toBytesView(content),
+            timestampS: asNumber(Number(rawTimestamp), 'privacy_token.t')
+        };
+    }
+    return result;
+}

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

@@ -10,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)) {
@@ -27,19 +28,20 @@ export async function processHistorySyncNotification(deps, notification) {
         pushnames: historySync.pushnames.length
     });
     const nowMs = Date.now();
-    const contacts = [];
+    const pendingWrites = [];
     for (const pn of historySync.pushnames) {
         if (!pn.id) {
             continue;
         }
-        contacts.push({
+        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);
+        }
     }
-    const threads = [];
-    const messages = [];
     let messagesCount = 0;
     for (const conversation of historySync.conversations) {
         const threadJid = conversation.id;
@@ -47,7 +49,7 @@ export async function processHistorySyncNotification(deps, notification) {
             deps.logger.debug('skipping history sync conversation without thread jid');
             continue;
         }
-        threads.push({
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistThreadAsync({
             jid: threadJid,
             name: conversation.name ?? undefined,
             unreadCount: conversation.unreadCount ?? undefined,
@@ -57,13 +59,16 @@ export async function processHistorySyncNotification(deps, notification) {
             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;
-            messages.push({
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
                 id: webMsg.key.id,
                 threadJid,
                 senderJid: webMsg.key.participant ?? undefined,
@@ -73,12 +78,35 @@ export async function processHistorySyncNotification(deps, notification) {
                     ? proto.Message.encode(webMsg.message).finish()
                     : undefined
             });
+            if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+                await flushPendingWrites(pendingWrites);
+            }
             messagesCount += 1;
         }
     }
-    await deps.contactStore.upsertBatch(contacts);
-    await deps.threadStore.upsertBatch(threads);
-    await deps.messageStore.upsertBatch(messages);
+    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 event = {
         syncType,
         messagesCount,
@@ -87,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');

package/dist/esm/client/incoming.js

@@ -1,9 +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 { 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([
@@ -30,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,
@@ -63,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();
         }
@@ -108,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;
     };
 }
@@ -138,6 +157,8 @@ 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);
@@ -172,7 +193,12 @@ export function createIncomingNotificationHandler(options) {
                 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) {
@@ -210,7 +236,11 @@ export function createIncomingGroupNotificationHandler(options) {
                 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,15 +1,20 @@
 import { proto } from '../proto.js';
 import { toError } from '../util/primitives.js';
-async function persistContacts(contactStore, event, nowMs) {
-    const candidateJids = [event.senderJid, event.rawNode.attrs.participant].filter((jid) => !!jid);
-    if (candidateJids.length === 0) {
+function persistContacts(writeBehind, event, nowMs) {
+    const senderJid = event.senderJid;
+    const participantJid = event.rawNode.attrs.participant;
+    if (!senderJid && !participantJid) {
         return;
     }
-    const contacts = [...new Set(candidateJids)].map((jid) => ({ jid, lastUpdatedMs: nowMs }));
-    await contactStore.upsertBatch(contacts);
+    if (senderJid) {
+        writeBehind.persistContact({ jid: senderJid, lastUpdatedMs: nowMs });
+    }
+    if (participantJid && participantJid !== senderJid) {
+        writeBehind.persistContact({ jid: participantJid, 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;
@@ -19,22 +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/bytes.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);
+    }
+}