zapo-js 0.1.2 → 0.2.0

package/dist/client/events/devices.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICE_NOTIFICATION_ACTIONS = void 0;
+exports.parseDeviceNotification = parseDeviceNotification;
+const jid_1 = require("../../protocol/jid");
+const helpers_1 = require("../../transport/node/helpers");
+exports.DEVICE_NOTIFICATION_ACTIONS = Object.freeze({
+    ADD: 'add',
+    REMOVE: 'remove',
+    UPDATE: 'update'
+});
+function parseDeviceNotification(node) {
+    const stanzaId = node.attrs.id;
+    const fromJid = node.attrs.from;
+    if (!stanzaId || !fromJid) {
+        return null;
+    }
+    let action;
+    let actionNode;
+    if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+    }
+    else if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.ADD)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.ADD;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.ADD);
+    }
+    else if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+    }
+    else {
+        return null;
+    }
+    const devices = [];
+    if (action !== exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE && actionNode) {
+        const deviceNodes = (0, helpers_1.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 = (0, jid_1.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 === exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE ? actionNode?.attrs.hash : undefined,
+        devices
+    };
+}

package/dist/client/events/group.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseParticipants = parseParticipants;
 exports.parseGroupNotificationEvents = parseGroupNotificationEvents;
+const incoming_1 = require("../incoming");
 const constants_1 = require("../../protocol/constants");
 const nodes_1 = require("../../protocol/nodes");
 const helpers_1 = require("../../transport/node/helpers");
@@ -103,15 +104,6 @@ function createBaseGroupEvent(notificationNode, actionNode) {
         timestampSeconds: (0, primitives_1.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 = (0, helpers_1.findNodeChild)(actionNode, nodes_1.WA_NODE_TAGS.GROUP);
     if (!groupNode) {
@@ -417,13 +409,13 @@ function parseGroupNotificationEvents(notificationNode) {
         try {
             const parsedEvent = parseGroupActionNode(notificationNode, actionNode);
             if (!parsedEvent) {
-                unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
+                unhandled.push((0, incoming_1.createUnhandledIncomingNodeEvent)(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.not_supported`));
                 continue;
             }
             events.push(parsedEvent);
         }
         catch {
-            unhandled.push(createUnhandledStanzaEvent(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
+            unhandled.push((0, incoming_1.createUnhandledIncomingNodeEvent)(notificationNode, `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.${actionNode.tag}.parse_failed`));
         }
     }
     return {

package/dist/client/events/identity.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIdentityChangeNotification = parseIdentityChangeNotification;
+const helpers_1 = require("../../transport/node/helpers");
+function parseIdentityChangeNotification(node) {
+    const child = (0, helpers_1.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/client/events/privacy-token.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrivacyTokenNotification = parsePrivacyTokenNotification;
+const privacy_token_1 = require("../../protocol/privacy-token");
+const helpers_1 = require("../../transport/node/helpers");
+const bytes_1 = require("../../util/bytes");
+const coercion_1 = require("../../util/coercion");
+function parsePrivacyTokenNotification(node) {
+    const tokensNode = (0, helpers_1.findNodeChild)(node, privacy_token_1.WA_PRIVACY_TOKEN_TAGS.TOKENS);
+    if (!tokensNode) {
+        return [];
+    }
+    const children = (0, helpers_1.getNodeChildren)(tokensNode);
+    const result = [];
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child.tag !== privacy_token_1.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: (0, bytes_1.toBytesView)(content),
+            timestampS: (0, coercion_1.asNumber)(Number(rawTimestamp), 'privacy_token.t')
+        };
+    }
+    return result;
+}

package/dist/client/history-sync.js

@@ -13,6 +13,7 @@ const HANDLED_SYNC_TYPES = new Set([
     _proto_1.proto.Message.HistorySyncType.FULL,
     _proto_1.proto.Message.HistorySyncType.PUSH_NAME
 ]);
+const HISTORY_SYNC_MAX_PENDING_WRITES = 1024;
 async function processHistorySyncNotification(deps, notification) {
     const syncType = notification.syncType;
     if (syncType === null || syncType === undefined || !HANDLED_SYNC_TYPES.has(syncType)) {
@@ -30,19 +31,20 @@ 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;
@@ -50,7 +52,7 @@ 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,
@@ -60,13 +62,16 @@ 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 = (0, primitives_1.longToNumber)(webMsg.messageTimestamp) * 1000;
-            messages.push({
+            pendingWrites[pendingWrites.length] = deps.writeBehind.persistMessageAsync({
                 id: webMsg.key.id,
                 threadJid,
                 senderJid: webMsg.key.participant ?? undefined,
@@ -76,12 +81,35 @@ async function processHistorySyncNotification(deps, notification) {
                     ? _proto_1.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: (0, primitives_1.longToNumber)(conversation.tcTokenTimestamp) || undefined,
+                    tcTokenSenderTimestamp: (0, primitives_1.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,
@@ -90,8 +118,21 @@ 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 (0, bytes_1.decodeProtoBytes)(notification.initialHistBootstrapInlinePayload, 'initialHistBootstrapInlinePayload');

package/dist/client/incoming.js

@@ -9,10 +9,17 @@ exports.createInfoBulletinNotificationEvent = createInfoBulletinNotificationEven
 exports.createUnhandledIncomingNodeEvent = createUnhandledIncomingNodeEvent;
 const group_1 = require("./events/group");
 const constants_1 = require("../protocol/constants");
-const message_1 = require("../transport/node/builders/message");
-const pairing_1 = require("../transport/node/builders/pairing");
+const global_1 = require("../transport/node/builders/global");
 const helpers_1 = require("../transport/node/helpers");
 const primitives_1 = require("../util/primitives");
+const FAILURE_REASON_TO_DISCONNECT = {
+    401: constants_1.WA_DISCONNECT_REASONS.FAILURE_NOT_AUTHORIZED,
+    403: constants_1.WA_DISCONNECT_REASONS.FAILURE_LOCKED,
+    406: constants_1.WA_DISCONNECT_REASONS.FAILURE_BANNED,
+    405: constants_1.WA_DISCONNECT_REASONS.FAILURE_CLIENT_TOO_OLD,
+    409: constants_1.WA_DISCONNECT_REASONS.FAILURE_BAD_USER_AGENT,
+    503: constants_1.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([
@@ -39,6 +46,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']);
 function createIncomingBaseEvent(node) {
     return {
         rawNode: node,
@@ -72,7 +81,9 @@ function classifyNotificationType(notificationType) {
 }
 async function applyFailureAction(options, reason, clearStoredCredentials) {
     try {
-        await options.disconnect();
+        options.stopComms();
+        const disconnectReason = FAILURE_REASON_TO_DISCONNECT[reason] ?? constants_1.WA_DISCONNECT_REASONS.STREAM_ERROR_OTHER;
+        await options.disconnect(disconnectReason, clearStoredCredentials, reason);
         if (clearStoredCredentials) {
             await options.clearStoredCredentials();
         }
@@ -117,11 +128,19 @@ function createIncomingReceiptHandler(options) {
                 await options.handleIncomingRetryReceipt(node);
             }
             else {
-                await sendSafeAck(options.logger, options.sendNode, (0, message_1.buildInboundRetryReceiptAckNode)(node));
+                await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+                    kind: 'receipt',
+                    node,
+                    retryType: true
+                }));
             }
             return true;
         }
-        await sendSafeAck(options.logger, options.sendNode, (0, message_1.buildInboundReceiptAckNode)(node));
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'receipt',
+            node,
+            includeParticipant: receiptType !== 'server-error'
+        }));
         return true;
     };
 }
@@ -147,6 +166,8 @@ function createIncomingFailureHandler(options) {
 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 = (0, helpers_1.getFirstNodeChild)(node)?.tag;
         const baseEvent = createIncomingBaseEvent(node);
@@ -181,7 +202,12 @@ function createIncomingNotificationHandler(options) {
                 reason: `notification.${notificationType || 'unknown'}.not_supported`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'notification',
+            node,
+            includeParticipant: includeParticipantInAck,
+            includeType: includeTypeInAck
+        }));
         if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
             const collectionsCsv = serverSyncCollections.join(',');
             if (!options.syncAppState) {
@@ -219,7 +245,11 @@ function createIncomingGroupNotificationHandler(options) {
                 reason: `notification.${constants_1.WA_NOTIFICATION_TYPES.GROUP}.empty`
             });
         }
-        await sendSafeAck(options.logger, options.sendNode, (0, pairing_1.buildNotificationAckNode)(node));
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'notification',
+            node,
+            includeParticipant: true
+        }));
         return true;
     };
 }

package/dist/client/mailbox.js

@@ -3,16 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.persistIncomingMailboxEntities = persistIncomingMailboxEntities;
 const _proto_1 = require("../proto.js");
 const primitives_1 = require("../util/primitives");
-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 });
+    }
 }
-async function persistIncomingMailboxEntities(options) {
-    const { logger, contactStore, messageStore, event } = options;
+function persistIncomingMailboxEntities(options) {
+    const { logger, writeBehind, event } = options;
     const { stanzaId, chatJid } = event;
     if (!stanzaId || !chatJid) {
         return;
@@ -22,22 +27,18 @@ async function persistIncomingMailboxEntities(options) {
         const messageBytes = event.message
             ? _proto_1.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/client/messages.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMediaMessageContent = buildMediaMessageContent;
 exports.getMediaConn = getMediaConn;
+const node_fs_1 = require("node:fs");
 const conn_1 = require("../media/conn");
 const constants_1 = require("../media/constants");
 const WaMediaCrypto_1 = require("../media/WaMediaCrypto");
@@ -9,7 +10,6 @@ const content_1 = require("../message/content");
 const constants_2 = require("../protocol/constants");
 const media_1 = require("../transport/node/builders/media");
 const bytes_1 = require("../util/bytes");
-const bytes_2 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 async function buildMediaMessageContent(options, content) {
     if (typeof content === 'string') {
@@ -35,15 +35,29 @@ 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 = (0, bytes_2.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, (0, bytes_1.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,
@@ -71,6 +85,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: {
@@ -97,24 +120,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 = (0, bytes_1.bytesToBase64UrlSafe)(fileEncSha256);
+    const uploadPath = constants_1.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(bytes_1.TEXT_DECODER.decode(body));
+    }
+    catch (error) {
+        throw new Error(`media upload returned invalid json: ${(0, primitives_1.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_1.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_1.WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes),
         getMediaConn(options)
     ]);
     const selectedHost = mediaConn.hosts.find((host) => !host.isFallback)?.hostname ?? mediaConn.hosts[0].hostname;
-    const uploadPath = constants_1.MEDIA_UPLOAD_PATHS[uploadType];
-    const hashToken = (0, bytes_1.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,
@@ -127,26 +172,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(bytes_2.TEXT_DECODER.decode(uploadBody));
-    }
-    catch (error) {
-        throw new Error(`media upload returned invalid json: ${(0, primitives_1.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_1.WaMediaCrypto.generateMediaKey();
+    const encResult = await WaMediaCrypto_1.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 = (0, node_fs_1.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_1.WaMediaCrypto.cleanupEncryptedFile(encResult.filePath);
+    }
+}