zapo-js 0.1.2 → 0.3.0

package/dist/client/mailbox.js

@@ -1,18 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.persistIncomingMailboxEntities = persistIncomingMailboxEntities;
+const content_1 = require("../message/content");
 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, messageSecretStore, event } = options;
     const { stanzaId, chatJid } = event;
     if (!stanzaId || !chatJid) {
         return;
@@ -22,22 +28,33 @@ 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);
+        const rawSecret = event.message?.messageContextInfo?.messageSecret;
+        if (rawSecret &&
+            rawSecret.length > 0 &&
+            event.message &&
+            (0, content_1.needsSecretPersistence)(event.message)) {
+            const senderJid = event.senderJid ?? event.rawNode.attrs.participant ?? '';
+            void messageSecretStore
+                .set(stanzaId, { secret: rawSecret, senderJid })
+                .catch((error) => {
+                logger.warn('failed to persist message secret', {
+                    id: stanzaId,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            });
+        }
     }
     catch (error) {
         logger.warn('failed to persist incoming mailbox entities', {

package/dist/client/media.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileHead = readFileHead;
+exports.parseWebpAnimation = parseWebpAnimation;
+exports.isReadableStream = isReadableStream;
+exports.cleanupTempFile = cleanupTempFile;
+exports.resolveMediaInputs = resolveMediaInputs;
+exports.hasMediaProcessingTasks = hasMediaProcessingTasks;
+exports.runMediaProcessor = runMediaProcessor;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const promises_2 = require("node:stream/promises");
+const bytes_1 = require("../util/bytes");
+const primitives_1 = require("../util/primitives");
+async function readFileHead(filePath, bytes) {
+    const fh = await (0, promises_1.open)(filePath, 'r');
+    try {
+        const buf = new Uint8Array(bytes);
+        const { bytesRead } = await fh.read(buf, 0, bytes, 0);
+        return buf.subarray(0, bytesRead);
+    }
+    finally {
+        await fh.close();
+    }
+}
+const RIFF_HEADER_SIZE = 12;
+const CHUNK_HEADER_SIZE = 8;
+const CHUNK_ID_SIZE = 4;
+const ANMF_ID = [0x41, 0x4e, 0x4d, 0x46];
+function parseWebpAnimation(data) {
+    if (data.byteLength < RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE)
+        return null;
+    let offset = RIFF_HEADER_SIZE;
+    if (data[offset] !== 0x56 ||
+        data[offset + 1] !== 0x50 ||
+        data[offset + 2] !== 0x38 ||
+        data[offset + 3] !== 0x58) {
+        return null;
+    }
+    // Skip VP8X chunk: 8 byte header + 10 byte payload
+    offset += CHUNK_HEADER_SIZE + 10;
+    while (offset + CHUNK_HEADER_SIZE <= data.byteLength) {
+        const isAnmf = data[offset] === ANMF_ID[0] &&
+            data[offset + 1] === ANMF_ID[1] &&
+            data[offset + 2] === ANMF_ID[2] &&
+            data[offset + 3] === ANMF_ID[3];
+        const sizeOffset = offset + CHUNK_ID_SIZE;
+        if (sizeOffset + 4 > data.byteLength)
+            return null;
+        let chunkSize = (data[sizeOffset] |
+            (data[sizeOffset + 1] << 8) |
+            (data[sizeOffset + 2] << 16) |
+            (data[sizeOffset + 3] << 24)) >>>
+            0;
+        if (chunkSize % 2 !== 0)
+            chunkSize += 1;
+        const nextOffset = offset + CHUNK_HEADER_SIZE + chunkSize;
+        if (nextOffset <= offset || nextOffset > data.byteLength)
+            return null;
+        if (isAnmf) {
+            return { isAnimated: true, firstFrameLength: nextOffset };
+        }
+        offset = nextOffset;
+    }
+    return null;
+}
+const IMAGE_THUMB_MAX_EDGE = 320;
+const VIDEO_THUMB_MAX_EDGE = 48;
+const STICKER_THUMB_MAX_EDGE = 100;
+const EMPTY_PROCESSED = {};
+function isReadableStream(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'pipe' in value &&
+        typeof value.pipe === 'function');
+}
+async function streamToTempFile(source) {
+    const filePath = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `zapo-media-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    try {
+        await (0, promises_2.pipeline)(source, (0, node_fs_1.createWriteStream)(filePath));
+    }
+    catch (error) {
+        await (0, promises_1.unlink)(filePath).catch(() => undefined);
+        throw error;
+    }
+    return filePath;
+}
+async function cleanupTempFile(filePath) {
+    await (0, promises_1.unlink)(filePath).catch(() => undefined);
+}
+async function resolveMediaInputs(shouldProcess, raw) {
+    if (typeof raw === 'string') {
+        return {
+            processorInput: raw,
+            uploadMedia: (0, node_fs_1.createReadStream)(raw)
+        };
+    }
+    if (isReadableStream(raw)) {
+        if (shouldProcess) {
+            const tempFilePath = await streamToTempFile(raw);
+            return {
+                processorInput: tempFilePath,
+                uploadMedia: (0, node_fs_1.createReadStream)(tempFilePath),
+                tempFilePath
+            };
+        }
+        return { uploadMedia: raw };
+    }
+    const bytes = (0, bytes_1.toBytesView)(raw);
+    return { processorInput: bytes, uploadMedia: bytes };
+}
+function shouldGenerateThumbnail(media, content) {
+    if (!media?.processor || media.generateThumbnail === false) {
+        return false;
+    }
+    switch (content.type) {
+        case 'image':
+            return content.jpegThumbnail === undefined && !!media.processor.generateImageThumbnail;
+        case 'video':
+        case 'ptv':
+            return content.jpegThumbnail === undefined && !!media.processor.generateVideoThumbnail;
+        case 'document':
+            return !!media.processor.generateImageThumbnail;
+        default:
+            return false;
+    }
+}
+function shouldProbeMedia(media, content) {
+    if (!media?.processor?.probeMedia || media.generateProbe === false) {
+        return false;
+    }
+    switch (content.type) {
+        case 'video':
+        case 'ptv':
+            return (content.seconds === undefined ||
+                content.width === undefined ||
+                content.height === undefined);
+        case 'audio':
+            return content.seconds === undefined;
+        default:
+            return false;
+    }
+}
+function shouldGenerateWaveform(media, content) {
+    return (!!media?.processor?.computeWaveform &&
+        media.generateWaveform !== false &&
+        content.type === 'audio' &&
+        content.waveform === undefined);
+}
+function shouldGenerateStickerThumbnail(media, content) {
+    return (!!media?.processor?.generateStickerThumbnail &&
+        media.generateStickerThumbnail !== false &&
+        content.type === 'sticker' &&
+        content.pngThumbnail === undefined);
+}
+function hasMediaProcessingTasks(media, content) {
+    return (shouldGenerateThumbnail(media, content) ||
+        shouldProbeMedia(media, content) ||
+        shouldGenerateWaveform(media, content) ||
+        shouldGenerateStickerThumbnail(media, content));
+}
+async function runProcessorStep(step, content, logger, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        logger.error('media processor step failed, skipping step', {
+            type: content.type,
+            step,
+            message: (0, primitives_1.toError)(error).message
+        });
+        return null;
+    }
+}
+async function runMediaProcessor(media, input, content, logger) {
+    const processor = media?.processor;
+    if (!processor || !hasMediaProcessingTasks(media, content) || !input)
+        return EMPTY_PROCESSED;
+    const result = {};
+    const isVideo = content.type === 'video' || content.type === 'ptv';
+    const thumbFn = isVideo ? processor.generateVideoThumbnail : processor.generateImageThumbnail;
+    const thumbMaxEdge = isVideo ? VIDEO_THUMB_MAX_EDGE : IMAGE_THUMB_MAX_EDGE;
+    const thumbTask = shouldGenerateThumbnail(media, content)
+        ? runProcessorStep('thumbnail', content, logger, () => thumbFn(input, thumbMaxEdge))
+        : null;
+    const probeTask = shouldProbeMedia(media, content)
+        ? runProcessorStep('probe', content, logger, () => processor.probeMedia(input))
+        : null;
+    const [thumb, probe] = await Promise.all([thumbTask, probeTask]);
+    if (thumb) {
+        result.jpegThumbnail = thumb.jpegThumbnail;
+        if (!isVideo && !probe) {
+            result.width = thumb.width;
+            result.height = thumb.height;
+        }
+    }
+    if (probe) {
+        if (probe.durationSeconds !== undefined &&
+            !('seconds' in content && content.seconds !== undefined)) {
+            result.seconds = Math.floor(probe.durationSeconds);
+        }
+        if (!('width' in content && content.width !== undefined) && probe.width !== undefined) {
+            result.width = probe.width;
+        }
+        if (!('height' in content && content.height !== undefined) && probe.height !== undefined) {
+            result.height = probe.height;
+        }
+    }
+    if (shouldGenerateWaveform(media, content)) {
+        const waveformResult = await runProcessorStep('waveform', content, logger, () => processor.computeWaveform(input));
+        if (waveformResult) {
+            result.waveform = waveformResult.waveform;
+            if (result.seconds === undefined &&
+                !('seconds' in content && content.seconds !== undefined)) {
+                result.seconds = Math.floor(waveformResult.durationSeconds);
+            }
+        }
+    }
+    if (content.type === 'sticker') {
+        if (shouldGenerateStickerThumbnail(media, content)) {
+            const stickerThumb = await runProcessorStep('stickerThumbnail', content, logger, () => processor.generateStickerThumbnail(input, STICKER_THUMB_MAX_EDGE));
+            if (stickerThumb) {
+                result.pngThumbnail = stickerThumb.pngThumbnail;
+                result.width = stickerThumb.width;
+                result.height = stickerThumb.height;
+            }
+        }
+        if (content.isAnimated === undefined) {
+            const header = typeof input === 'string' ? await readFileHead(input, 100) : input;
+            const anim = parseWebpAnimation(header);
+            if (anim) {
+                result.isAnimated = true;
+                result.firstFrameLength = anim.firstFrameLength;
+            }
+            else {
+                result.isAnimated = false;
+            }
+        }
+    }
+    return result;
+}