zapo-js 0.2.0 → 1.0.0

package/dist/client/messaging/messages.js

@@ -0,0 +1,671 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMediaMessageContent = buildMediaMessageContent;
+exports.getMediaConn = getMediaConn;
+const node_fs_1 = require("node:fs");
+const node_stream_1 = require("node:stream");
+const media_1 = require("../media");
+const _crypto_1 = require("../../crypto/index.js");
+const constants_1 = require("../../media/constants");
+const WaMediaCrypto_1 = require("../../media/crypto/WaMediaCrypto");
+const sticker_pack_1 = require("../../media/sticker/sticker-pack");
+const conn_1 = require("../../media/transfer/conn");
+const builder_1 = require("../../message/addons/link-preview/builder");
+const addon_crypto_1 = require("../../message/crypto/addon-crypto");
+const use_case_secret_1 = require("../../message/crypto/use-case-secret");
+const content_1 = require("../../message/encode/content");
+const sticker_pack_2 = require("../../message/kinds/sticker-pack");
+const _proto_1 = require("../../proto.js");
+const constants_2 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
+const media_2 = require("../../transport/node/builders/media");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
+const VOICE_NOTE_MIMETYPE = 'audio/ogg; codecs=opus';
+function requireCtxField(ctx, field, kind) {
+    const value = ctx ? ctx[field] : undefined;
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${kind} message requires ${field} in build context`);
+    }
+}
+function buildMessageKey(remoteJid, fromMe, id, participant) {
+    return {
+        remoteJid,
+        fromMe,
+        id,
+        ...(participant ? { participant } : {})
+    };
+}
+/**
+ * Builds the proto key for a reply/edit/reaction/revoke/pin target. `remoteJid`
+ * is forced to the send recipient and `participant` is dropped in 1:1 chats
+ * (only meaningful in groups/broadcasts).
+ */
+function targetMessageKey(remoteJid, key) {
+    const inGroup = (0, jid_1.isGroupJid)(remoteJid) || (0, jid_1.isBroadcastJid)(remoteJid);
+    return buildMessageKey(remoteJid, key.fromMe, key.id, inGroup ? key.participant : undefined);
+}
+function buildReactionMessage(content, serverClock, ctx) {
+    requireCtxField(ctx, 'to', 'reaction');
+    return {
+        reactionMessage: {
+            key: targetMessageKey(ctx.to, (0, content_1.resolveMessageTarget)(content.target)),
+            text: content.emoji,
+            senderTimestampMs: content.senderTimestampMs ?? serverClock.nowMs()
+        }
+    };
+}
+function buildRevokeMessage(content, ctx) {
+    requireCtxField(ctx, 'to', 'revoke');
+    return {
+        protocolMessage: {
+            type: _proto_1.proto.Message.ProtocolMessage.Type.REVOKE,
+            key: targetMessageKey(ctx.to, (0, content_1.resolveMessageTarget)(content.target))
+        }
+    };
+}
+// wa-web default pin expiry preset (24h). Receivers drop pins that arrive
+// without a duration, so always advertise one. Override via `durationSecs`.
+const WA_PIN_DEFAULT_DURATION_SECS = 86400;
+function buildPinMessage(content, serverClock, ctx) {
+    requireCtxField(ctx, 'to', content.type);
+    const isPin = content.type === 'pin';
+    return {
+        pinInChatMessage: {
+            key: targetMessageKey(ctx.to, (0, content_1.resolveMessageTarget)(content.target)),
+            type: isPin
+                ? _proto_1.proto.Message.PinInChatMessage.Type.PIN_FOR_ALL
+                : _proto_1.proto.Message.PinInChatMessage.Type.UNPIN_FOR_ALL,
+            senderTimestampMs: content.senderTimestampMs ?? serverClock.nowMs()
+        },
+        messageContextInfo: {
+            messageAddOnDurationInSecs: isPin
+                ? (content.durationSecs ?? WA_PIN_DEFAULT_DURATION_SECS)
+                : 0
+        }
+    };
+}
+function buildKeepMessage(content, serverClock, ctx) {
+    requireCtxField(ctx, 'to', content.type);
+    return {
+        keepInChatMessage: {
+            key: targetMessageKey(ctx.to, (0, content_1.resolveMessageTarget)(content.target)),
+            keepType: content.type === 'keep'
+                ? _proto_1.proto.KeepType.KEEP_FOR_ALL
+                : _proto_1.proto.KeepType.UNDO_KEEP_FOR_ALL,
+            timestampMs: content.timestampMs ?? serverClock.nowMs()
+        }
+    };
+}
+function buildPollCreationMessage(content) {
+    if (content.options.length === 0) {
+        throw new Error('poll message requires at least one option');
+    }
+    const options = content.options.map((opt) => ({
+        optionName: typeof opt === 'string' ? opt : opt.name
+    }));
+    return {
+        pollCreationMessageV3: {
+            name: content.name,
+            options,
+            selectableOptionsCount: content.selectableCount ?? 1,
+            ...(content.allowAddOption !== undefined
+                ? { allowAddOption: content.allowAddOption }
+                : {}),
+            ...(content.hideParticipantName !== undefined
+                ? { hideParticipantName: content.hideParticipantName }
+                : {})
+        }
+    };
+}
+function buildEventMessage(content) {
+    const eventMessage = {
+        name: content.name,
+        startTime: content.startTime,
+        isCanceled: content.isCanceled ?? false
+    };
+    if (content.description !== undefined)
+        eventMessage.description = content.description;
+    if (content.endTime !== undefined)
+        eventMessage.endTime = content.endTime;
+    if (content.joinLink !== undefined)
+        eventMessage.joinLink = content.joinLink;
+    if (content.extraGuestsAllowed !== undefined)
+        eventMessage.extraGuestsAllowed = content.extraGuestsAllowed;
+    if (content.isScheduleCall !== undefined)
+        eventMessage.isScheduleCall = content.isScheduleCall;
+    if (content.hasReminder !== undefined)
+        eventMessage.hasReminder = content.hasReminder;
+    if (content.reminderOffsetSec !== undefined)
+        eventMessage.reminderOffsetSec = content.reminderOffsetSec;
+    if (content.location) {
+        eventMessage.location = {
+            degreesLatitude: content.location.latitude,
+            degreesLongitude: content.location.longitude,
+            ...(content.location.name !== undefined ? { name: content.location.name } : {}),
+            ...(content.location.address !== undefined ? { address: content.location.address } : {})
+        };
+    }
+    return { eventMessage };
+}
+const EVENT_RESPONSE_ENUM = {
+    going: _proto_1.proto.Message.EventResponseMessage.EventResponseType.GOING,
+    not_going: _proto_1.proto.Message.EventResponseMessage.EventResponseType.NOT_GOING,
+    maybe: _proto_1.proto.Message.EventResponseMessage.EventResponseType.MAYBE
+};
+async function encryptAddonForOutgoing(input) {
+    const secret = await (0, use_case_secret_1.createUseCaseSecret)({
+        messageSecret: input.messageSecret,
+        stanzaId: input.parentStanzaId,
+        parentMsgOriginalSender: input.parentMsgOriginalSender,
+        modificationSender: input.modificationSender,
+        modificationType: input.modificationType
+    });
+    const iv = await (0, _crypto_1.randomBytesAsync)(12);
+    const additionalData = (0, addon_crypto_1.shouldUseAddonAdditionalData)(input.modificationType)
+        ? (0, addon_crypto_1.buildAddonAdditionalData)(input.parentStanzaId, input.modificationSender)
+        : undefined;
+    const encPayload = (0, _crypto_1.aesGcmEncrypt)(secret, iv, input.payload, additionalData);
+    return { encPayload, encIv: iv };
+}
+async function buildPollVoteMessage(content, serverClock, ctx) {
+    requireCtxField(ctx, 'outgoingStanzaId', 'poll-vote');
+    requireCtxField(ctx, 'meJid', 'poll-vote');
+    if (content.selectedOptionNames.length === 0) {
+        throw new Error('poll-vote requires at least one selected option');
+    }
+    const selectedOptions = content.selectedOptionNames.map((name) => (0, _crypto_1.sha256)(bytes_1.TEXT_ENCODER.encode(name)));
+    const payload = _proto_1.proto.Message.PollVoteMessage.encode({ selectedOptions }).finish();
+    const { encPayload, encIv } = await encryptAddonForOutgoing({
+        messageSecret: content.poll.messageSecret,
+        parentStanzaId: content.poll.id,
+        parentMsgOriginalSender: (0, jid_1.toUserJid)(content.poll.authorJid),
+        modificationSender: (0, jid_1.toUserJid)(ctx.meJid),
+        modificationType: use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE,
+        payload
+    });
+    return {
+        pollUpdateMessage: {
+            pollCreationMessageKey: buildMessageKey(ctx.to, content.poll.fromMe, content.poll.id, content.poll.participant),
+            vote: { encPayload, encIv },
+            senderTimestampMs: content.senderTimestampMs ?? serverClock.nowMs()
+        }
+    };
+}
+async function buildEventResponseMessage(content, serverClock, ctx) {
+    requireCtxField(ctx, 'outgoingStanzaId', 'event-response');
+    requireCtxField(ctx, 'meJid', 'event-response');
+    const responseProto = {
+        response: EVENT_RESPONSE_ENUM[content.response],
+        timestampMs: content.timestampMs ?? serverClock.nowMs()
+    };
+    if (content.extraGuestCount !== undefined) {
+        responseProto.extraGuestCount = content.extraGuestCount;
+    }
+    const payload = _proto_1.proto.Message.EventResponseMessage.encode(responseProto).finish();
+    const { encPayload, encIv } = await encryptAddonForOutgoing({
+        messageSecret: content.event.messageSecret,
+        parentStanzaId: content.event.id,
+        parentMsgOriginalSender: (0, jid_1.toUserJid)(content.event.authorJid),
+        modificationSender: (0, jid_1.toUserJid)(ctx.meJid),
+        modificationType: use_case_secret_1.WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE,
+        payload
+    });
+    return {
+        encEventResponseMessage: {
+            eventCreationMessageKey: buildMessageKey(ctx.to, content.event.fromMe, content.event.id, content.event.participant),
+            encPayload,
+            encIv
+        }
+    };
+}
+async function buildMediaMessageContent(options, content, ctx) {
+    if (typeof content === 'string') {
+        return { message: { conversation: content } };
+    }
+    if ((0, content_1.isSendTextMessage)(content)) {
+        if (options.linkPreviewResolver) {
+            try {
+                const preview = await options.linkPreviewResolver(content);
+                if (preview !== null) {
+                    return {
+                        message: (0, builder_1.buildExtendedTextWithPreview)(content.text, preview.resolved, preview.thumbnailFields)
+                    };
+                }
+            }
+            catch (error) {
+                options.logger.warn('link preview resolver failed, sending plain text', {
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+        return { message: { extendedTextMessage: { text: content.text } } };
+    }
+    if ((0, content_1.isSendReactionMessage)(content)) {
+        return { message: buildReactionMessage(content, options.serverClock, ctx) };
+    }
+    if ((0, content_1.isSendRevokeMessage)(content))
+        return { message: buildRevokeMessage(content, ctx) };
+    if ((0, content_1.isSendPinMessage)(content)) {
+        return { message: buildPinMessage(content, options.serverClock, ctx) };
+    }
+    if ((0, content_1.isSendKeepMessage)(content)) {
+        return { message: buildKeepMessage(content, options.serverClock, ctx) };
+    }
+    if ((0, content_1.isSendPollMessage)(content))
+        return { message: buildPollCreationMessage(content) };
+    if ((0, content_1.isSendEventMessage)(content))
+        return { message: buildEventMessage(content) };
+    if ((0, content_1.isSendPollVoteMessage)(content)) {
+        return { message: await buildPollVoteMessage(content, options.serverClock, ctx) };
+    }
+    if ((0, content_1.isSendEventResponseMessage)(content)) {
+        return { message: await buildEventResponseMessage(content, options.serverClock, ctx) };
+    }
+    if ((0, content_1.isSendMediaMessage)(content)) {
+        return buildMediaMessage(options, content);
+    }
+    if (!content || typeof content !== 'object') {
+        throw new Error('invalid message content');
+    }
+    return { message: content };
+}
+async function getMediaConn(options, forceRefresh = false) {
+    const cached = options.getMediaConnCache();
+    if (!forceRefresh && cached && Date.now() + constants_1.MEDIA_CONN_CACHE_GRACE_MS < cached.expiresAtMs) {
+        return cached;
+    }
+    const response = await options.queryWithContext('media_conn.fetch', (0, media_2.buildMediaConnIq)(), options.iqTimeoutMs ?? constants_2.WA_DEFAULTS.IQ_TIMEOUT_MS);
+    const mediaConn = (0, conn_1.parseMediaConnResponse)(response, Date.now());
+    options.setMediaConnCache(mediaConn);
+    return mediaConn;
+}
+function needsSidecar(content) {
+    return content.type === 'video' || content.type === 'ptv' || content.type === 'audio';
+}
+function resolveUploadType(content) {
+    if (content.type === 'video' && content.gifPlayback)
+        return 'gif';
+    if (content.type === 'audio' && content.ptt)
+        return 'ptt';
+    return content.type;
+}
+async function resolveMimetype(content, media, processorInput, ctx) {
+    if (content.mimetype)
+        return content.mimetype;
+    if (content.type === 'sticker')
+        return 'image/webp';
+    const detect = media?.processor?.detectMimetype;
+    if (detect && processorInput !== undefined) {
+        const detected = await detect(processorInput, ctx);
+        if (detected)
+            return detected;
+    }
+    throw new Error(`mimetype is required for ${content.type} messages (or configure a WaMediaProcessor with detectMimetype)`);
+}
+async function buildMediaMessage(options, content) {
+    if (content.type === 'sticker-pack') {
+        return buildStickerPackMediaMessage(options, content);
+    }
+    const processorCtx = {
+        logger: (0, media_1.getScopedMediaLogger)(options.logger)
+    };
+    if ((0, media_1.shouldNormalizeVoiceNote)(options.media, content)) {
+        const sourceInput = content.media instanceof ArrayBuffer ? (0, bytes_1.toBytesView)(content.media) : content.media;
+        try {
+            const normalizedStream = await options.media.processor.normalizeVoiceNote(sourceInput, processorCtx);
+            if (normalizedStream) {
+                content = { ...content, media: normalizedStream, mimetype: VOICE_NOTE_MIMETYPE };
+            }
+        }
+        catch (error) {
+            options.logger.warn('voice note normalize failed, sending original media', {
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
+    const needsMimetypeDetection = !content.mimetype &&
+        content.type !== 'sticker' &&
+        !!options.media?.processor?.detectMimetype &&
+        (0, media_1.isReadableStream)(content.media);
+    const needsTempFile = (0, media_1.hasMediaProcessingTasks)(options.media, content) ||
+        (content.type === 'sticker' && content.firstFrameLength === undefined) ||
+        needsMimetypeDetection;
+    const resolved = await (0, media_1.resolveMediaInputs)(needsTempFile, content.media);
+    const mimetype = await resolveMimetype(content, options.media, resolved.processorInput, processorCtx);
+    try {
+        let detectedFirstFrameLength;
+        if (content.type === 'sticker' &&
+            content.firstFrameLength === undefined &&
+            resolved.processorInput) {
+            const input = resolved.processorInput;
+            const header = typeof input === 'string' ? await (0, media_1.readFileHead)(input, 100) : input.subarray(0, 100);
+            detectedFirstFrameLength = (0, media_1.parseWebpAnimation)(header)?.firstFrameLength;
+        }
+        const firstFrameLength = content.type === 'sticker'
+            ? (content.firstFrameLength ?? detectedFirstFrameLength)
+            : undefined;
+        const uploadPromise = (0, media_1.isReadableStream)(resolved.uploadMedia)
+            ? uploadMediaStream(options, content, resolved.uploadMedia, firstFrameLength, mimetype)
+            : uploadMediaBytes(options, content, resolved.uploadMedia, firstFrameLength, mimetype);
+        const processPromise = (0, media_1.runMediaProcessor)(options.media, resolved.processorInput, content, options.logger);
+        const [uploadResult, processResult] = await Promise.allSettled([
+            uploadPromise,
+            processPromise
+        ]);
+        if (uploadResult.status === 'rejected')
+            throw uploadResult.reason;
+        if (processResult.status === 'rejected')
+            throw processResult.reason;
+        const uploaded = uploadResult.value;
+        const processed = processResult.value;
+        const mediaKeyTimestamp = options.serverClock.nowSeconds();
+        const uploadedFields = {
+            url: uploaded.url,
+            fileSha256: uploaded.fileSha256,
+            fileLength: uploaded.fileLength,
+            mediaKey: uploaded.mediaKey,
+            fileEncSha256: uploaded.fileEncSha256,
+            directPath: uploaded.directPath,
+            mediaKeyTimestamp,
+            mimetype
+        };
+        const uploadSummary = {
+            url: uploaded.url,
+            directPath: uploaded.directPath,
+            fileSha256: uploaded.fileSha256,
+            fileLength: uploaded.fileLength,
+            metadataUrl: uploaded.metadataUrl
+        };
+        function spread(c) {
+            const result = {};
+            for (const key in c) {
+                if (key !== 'type' &&
+                    key !== 'media' &&
+                    key !== 'fileLength' &&
+                    key !== 'mimetype') {
+                    result[key] = c[key];
+                }
+            }
+            return result;
+        }
+        switch (content.type) {
+            case 'image':
+                return {
+                    upload: uploadSummary,
+                    message: {
+                        imageMessage: {
+                            ...spread(content),
+                            ...uploadedFields,
+                            width: content.width ?? processed.width,
+                            height: content.height ?? processed.height,
+                            jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                        }
+                    }
+                };
+            case 'video':
+                return {
+                    upload: uploadSummary,
+                    message: {
+                        videoMessage: {
+                            ...spread(content),
+                            ...uploadedFields,
+                            seconds: content.seconds ?? processed.seconds,
+                            width: content.width ?? processed.width,
+                            height: content.height ?? processed.height,
+                            jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                            streamingSidecar: uploaded.streamingSidecar,
+                            metadataUrl: uploaded.metadataUrl
+                        }
+                    }
+                };
+            case 'ptv':
+                return {
+                    upload: uploadSummary,
+                    message: {
+                        ptvMessage: {
+                            ...spread(content),
+                            ...uploadedFields,
+                            seconds: content.seconds ?? processed.seconds,
+                            width: content.width ?? processed.width,
+                            height: content.height ?? processed.height,
+                            jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail,
+                            streamingSidecar: uploaded.streamingSidecar
+                        }
+                    }
+                };
+            case 'audio':
+                return {
+                    upload: uploadSummary,
+                    message: {
+                        audioMessage: {
+                            ...spread(content),
+                            ...uploadedFields,
+                            seconds: content.seconds ?? processed.seconds,
+                            streamingSidecar: uploaded.streamingSidecar,
+                            waveform: content.waveform ?? processed.waveform
+                        }
+                    }
+                };
+            case 'document':
+                return {
+                    upload: uploadSummary,
+                    message: {
+                        documentMessage: {
+                            ...spread(content),
+                            ...uploadedFields,
+                            fileName: content.fileName ?? 'file',
+                            title: content.title ?? content.fileName ?? undefined,
+                            jpegThumbnail: content.jpegThumbnail ?? processed.jpegThumbnail
+                        }
+                    }
+                };
+            case 'sticker':
+                return {
+                    upload: uploadSummary,
+                    message: {
+                        stickerMessage: {
+                            ...spread(content),
+                            ...uploadedFields,
+                            width: content.width ?? processed.width,
+                            height: content.height ?? processed.height,
+                            pngThumbnail: content.pngThumbnail ?? processed.pngThumbnail,
+                            isAnimated: content.isAnimated ??
+                                processed.isAnimated ??
+                                firstFrameLength !== undefined,
+                            firstFrameLength: content.firstFrameLength ?? uploaded.firstFrameLength,
+                            firstFrameSidecar: content.firstFrameSidecar ?? uploaded.firstFrameSidecar,
+                            stickerSentTs: content.stickerSentTs ?? options.serverClock.nowMs()
+                        }
+                    }
+                };
+            default:
+                throw new Error(`unsupported media message type: ${String(content.type)}`);
+        }
+    }
+    finally {
+        if (resolved.tempFilePath) {
+            await (0, media_1.cleanupTempFile)(resolved.tempFilePath);
+        }
+    }
+}
+function resolveUploadPath(uploadType) {
+    const uploadPath = constants_1.MEDIA_UPLOAD_PATHS[uploadType];
+    if (!uploadPath) {
+        throw new Error(`unknown media upload type: ${String(uploadType)}`);
+    }
+    return uploadPath;
+}
+function parseUploadResponse(body, status) {
+    (0, media_1.assertMediaUploadStatus)(status, 'media upload');
+    const parsed = (0, media_1.parseMediaUploadJsonBody)(body, 'media upload');
+    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, firstFrameLength, mimetype) {
+    const uploadType = resolveUploadType(content);
+    const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
+    const [encrypted, mediaConn] = await Promise.all([
+        WaMediaCrypto_1.WaMediaCrypto.encryptBytes(uploadType, mediaKey, mediaBytes, {
+            sidecar: needsSidecar(content),
+            firstFrameLength
+        }),
+        getMediaConn(options)
+    ]);
+    const selectedHost = (0, media_1.selectMediaUploadHost)(mediaConn);
+    const uploadUrl = (0, media_1.buildMediaUploadUrl)(selectedHost, resolveUploadPath(uploadType), mediaConn.auth, encrypted.fileEncSha256);
+    options.logger.debug('sending media upload request', {
+        mediaType: content.type,
+        uploadType,
+        host: selectedHost
+    });
+    const uploadResponse = await options.mediaTransfer.uploadStream({
+        url: uploadUrl,
+        method: 'POST',
+        body: encrypted.ciphertextHmac,
+        contentLength: encrypted.ciphertextHmac.byteLength,
+        contentType: mimetype
+    });
+    const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+    const parsed = parseUploadResponse(responseBody, uploadResponse.status);
+    return {
+        ...parsed,
+        mediaKey,
+        fileSha256: encrypted.fileSha256,
+        fileEncSha256: encrypted.fileEncSha256,
+        fileLength: mediaBytes.byteLength,
+        streamingSidecar: encrypted.streamingSidecar,
+        firstFrameSidecar: encrypted.firstFrameSidecar,
+        firstFrameLength
+    };
+}
+async function uploadEncryptedStream(options, input) {
+    const encResult = await WaMediaCrypto_1.WaMediaCrypto.encryptToFile(input.cryptoType, input.mediaKey, input.plaintext, { sidecar: input.sidecar, firstFrameLength: input.firstFrameLength });
+    let readStream;
+    try {
+        const mediaConn = await getMediaConn(options);
+        const selectedHost = (0, media_1.selectMediaUploadHost)(mediaConn);
+        const uploadUrl = (0, media_1.buildMediaUploadUrl)(selectedHost, input.uploadPath, mediaConn.auth, encResult.fileEncSha256);
+        options.logger.debug(input.logLabel, {
+            host: selectedHost,
+            uploadPath: input.uploadPath,
+            plaintextLength: encResult.plaintextLength,
+            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: input.contentType
+        });
+        const responseBody = await options.mediaTransfer.readResponseBytes(uploadResponse);
+        const parsed = parseUploadResponse(responseBody, uploadResponse.status);
+        return {
+            ...parsed,
+            mediaKey: input.mediaKey,
+            fileSha256: encResult.fileSha256,
+            fileEncSha256: encResult.fileEncSha256,
+            fileLength: encResult.plaintextLength,
+            streamingSidecar: encResult.streamingSidecar,
+            firstFrameSidecar: encResult.firstFrameSidecar,
+            firstFrameLength: input.firstFrameLength
+        };
+    }
+    finally {
+        if (readStream && !readStream.closed) {
+            await new Promise((resolve) => {
+                readStream.once('close', resolve);
+                readStream.destroy();
+            });
+        }
+        await WaMediaCrypto_1.WaMediaCrypto.cleanupEncryptedFile(encResult.filePath);
+    }
+}
+async function uploadMediaStream(options, content, stream, firstFrameLength, mimetype) {
+    const cryptoType = resolveUploadType(content);
+    return uploadEncryptedStream(options, {
+        plaintext: stream,
+        mediaKey: await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey(),
+        cryptoType,
+        uploadPath: resolveUploadPath(cryptoType),
+        contentType: mimetype,
+        logLabel: 'sending media stream upload request',
+        sidecar: needsSidecar(content),
+        firstFrameLength
+    });
+}
+function openStickerPackInputStream(media) {
+    return typeof media === 'string' ? (0, node_fs_1.createReadStream)(media) : node_stream_1.Readable.from([media]);
+}
+async function buildStickerPackMediaMessage(options, content) {
+    (0, sticker_pack_2.validateStickerPackInput)(content);
+    if (content.coverThumbnail === undefined) {
+        throw new Error('sticker pack send requires coverThumbnail for non-newsletter recipients');
+    }
+    const coverThumbnail = content.coverThumbnail;
+    const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
+    const [bundle, cover] = await Promise.all([
+        uploadEncryptedStream(options, {
+            plaintext: (0, sticker_pack_1.createStickerPackZipStream)((0, sticker_pack_2.toStickerPackZipEntries)(content)),
+            mediaKey,
+            cryptoType: 'sticker-pack',
+            uploadPath: constants_1.MEDIA_UPLOAD_PATHS['sticker-pack'],
+            contentType: 'application/zip',
+            logLabel: 'sending sticker pack bundle upload',
+            sidecar: false
+        }),
+        uploadEncryptedStream(options, {
+            plaintext: openStickerPackInputStream(coverThumbnail),
+            mediaKey,
+            cryptoType: 'thumbnail-sticker-pack',
+            uploadPath: constants_1.MEDIA_UPLOAD_PATHS['thumbnail-sticker-pack'],
+            contentType: 'image/jpeg',
+            logLabel: 'sending sticker pack thumbnail upload',
+            sidecar: false
+        })
+    ]);
+    if (cover.fileLength === 0) {
+        throw new Error('sticker pack coverThumbnail is empty');
+    }
+    return {
+        upload: {
+            url: bundle.url,
+            directPath: bundle.directPath,
+            fileSha256: bundle.fileSha256,
+            fileLength: bundle.fileLength
+        },
+        message: {
+            stickerPackMessage: {
+                stickerPackId: content.stickerPackId,
+                name: content.name,
+                publisher: content.publisher,
+                stickers: (0, sticker_pack_2.toStickerPackProtoStickers)(content),
+                fileLength: bundle.fileLength,
+                fileSha256: bundle.fileSha256,
+                fileEncSha256: bundle.fileEncSha256,
+                mediaKey,
+                mediaKeyTimestamp: options.serverClock.nowSeconds(),
+                directPath: bundle.directPath,
+                thumbnailDirectPath: cover.directPath,
+                thumbnailSha256: cover.fileSha256,
+                thumbnailEncSha256: cover.fileEncSha256,
+                thumbnailWidth: content.thumbnailWidth ?? 252,
+                thumbnailHeight: content.thumbnailHeight ?? 252,
+                trayIconFileName: content.trayIcon.fileName,
+                stickerPackSize: bundle.fileLength,
+                stickerPackOrigin: _proto_1.proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+                imageDataHash: (0, bytes_1.bytesToBase64)(cover.fileSha256),
+                caption: content.caption,
+                packDescription: content.packDescription
+            }
+        }
+    };
+}