zapo-js 0.2.0 → 1.0.0

package/dist/client/messaging/ignore-key.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIgnoreKey = validateIgnoreKey;
+exports.extractIgnoreKeyContext = extractIgnoreKeyContext;
+exports.matchesIgnoreKey = matchesIgnoreKey;
+exports.createIgnoreKeyFilter = createIgnoreKeyFilter;
+const jid_1 = require("../../protocol/jid");
+const message_1 = require("../../protocol/message");
+const nodes_1 = require("../../protocol/nodes");
+const TAG_TO_KIND = {
+    [message_1.WA_MESSAGE_TAGS.MESSAGE]: 'message',
+    [message_1.WA_MESSAGE_TAGS.RECEIPT]: 'receipt',
+    [nodes_1.WA_NODE_TAGS.NOTIFICATION]: 'notification',
+    [nodes_1.WA_NODE_TAGS.PRESENCE]: 'presence',
+    [nodes_1.WA_NODE_TAGS.CHATSTATE]: 'chatstate',
+    [nodes_1.WA_NODE_TAGS.CALL]: 'call'
+};
+function validateIgnoreKey(d) {
+    if (d.remoteJid === undefined &&
+        d.fromMe === undefined &&
+        d.id === undefined &&
+        d.participant === undefined) {
+        throw new Error('ignoreKey: at least one match field required');
+    }
+    if (Array.isArray(d.remoteJid) && d.remoteJid.length === 0) {
+        throw new Error('ignoreKey: remoteJid array is empty');
+    }
+    if (d.only !== undefined && d.only.length === 0) {
+        throw new Error('ignoreKey: only array is empty');
+    }
+}
+function tryParseJid(jid) {
+    if (!jid)
+        return null;
+    try {
+        return (0, jid_1.parseJidFull)(jid);
+    }
+    catch {
+        return null;
+    }
+}
+function matchesAnyJid(actual, candidates) {
+    const a = tryParseJid(actual);
+    if (a === null)
+        return false;
+    for (const c of candidates) {
+        if (tryParseJid(c)?.userJid === a.userJid)
+            return true;
+    }
+    return false;
+}
+function collectFromCandidates(kind, attrs) {
+    const list = [];
+    if (attrs.from)
+        list.push(attrs.from);
+    if (kind === 'message') {
+        if (attrs.sender_pn)
+            list.push(attrs.sender_pn);
+        if (attrs.sender_lid)
+            list.push(attrs.sender_lid);
+    }
+    else if (kind === 'call' && attrs.sender_lid) {
+        list.push(attrs.sender_lid);
+    }
+    return list;
+}
+function collectParticipantCandidates(kind, attrs) {
+    const list = [];
+    if (attrs.participant)
+        list.push(attrs.participant);
+    if (kind === 'message') {
+        if (attrs.participant_pn)
+            list.push(attrs.participant_pn);
+        if (attrs.participant_lid)
+            list.push(attrs.participant_lid);
+    }
+    return list;
+}
+/**
+ * Builds the parsed context handed to a {@link WaIgnoreKeyPredicate}. Returns
+ * `null` when the node's tag is not one of the addressable kinds (`<iq>`, etc.).
+ */
+function extractIgnoreKeyContext(node, meJid) {
+    const kind = TAG_TO_KIND[node.tag];
+    if (kind === undefined)
+        return null;
+    const a = node.attrs;
+    const me = tryParseJid(meJid);
+    const fromCandidates = collectFromCandidates(kind, a);
+    const fromMe = me !== null && fromCandidates.some((f) => tryParseJid(f)?.address.user === me.address.user);
+    return {
+        kind,
+        remoteJid: a.from ?? null,
+        fromMe,
+        id: a.id,
+        participant: a.participant ?? null
+    };
+}
+/** Pure matcher. Exported for direct testing without a coordinator. */
+function matchesIgnoreKey(node, d, meJid) {
+    const ctx = extractIgnoreKeyContext(node, meJid);
+    if (ctx === null)
+        return false;
+    if (d.only !== undefined && !d.only.includes(ctx.kind))
+        return false;
+    const a = node.attrs;
+    const fromCandidates = collectFromCandidates(ctx.kind, a);
+    if (d.remoteJid !== undefined) {
+        const candidates = Array.isArray(d.remoteJid) ? d.remoteJid : [d.remoteJid];
+        if (!fromCandidates.some((f) => matchesAnyJid(f, candidates)))
+            return false;
+    }
+    if (d.participant !== undefined) {
+        const pCandidates = collectParticipantCandidates(ctx.kind, a);
+        if (!pCandidates.some((p) => matchesAnyJid(p, [d.participant])))
+            return false;
+    }
+    if (d.id !== undefined && ctx.id !== d.id)
+        return false;
+    if (d.fromMe !== undefined && d.fromMe !== ctx.fromMe)
+        return false;
+    return true;
+}
+function createIgnoreKeyFilter(input, getMeJid) {
+    if (typeof input === 'function') {
+        return (node) => {
+            const ctx = extractIgnoreKeyContext(node, getMeJid());
+            return ctx !== null && input(ctx);
+        };
+    }
+    return (node) => matchesIgnoreKey(node, input, getMeJid());
+}

package/dist/client/messaging/key-protocol.js

@@ -1,32 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAppStateSyncKeyProtocol = createAppStateSyncKeyProtocol;
-const padding_1 = require("../../message/padding");
 const _proto_1 = require("../../proto.js");
 const jid_1 = require("../../protocol/jid");
 const bytes_1 = require("../../util/bytes");
 function createAppStateSyncKeyProtocol(options) {
-    const { publishSignalMessage, fanoutResolver, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const { publishProtocolMessageToDevice, fanoutResolver, getCurrentCredentials, logger } = options;
     const requireCurrentIdentity = (context) => {
-        const meJid = getCurrentMeJid();
-        const meLid = getCurrentMeLid();
-        if (meJid || meLid) {
+        const credentials = getCurrentCredentials();
+        if (credentials?.meJid || credentials?.meLid) {
             return;
         }
         throw new Error(`${context} requires registered identity`);
     };
-    const publishProtocolMessageToDevice = async (deviceJid, protocolMessage) => {
-        const plaintext = await (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode({
-            protocolMessage
-        }).finish());
-        await publishSignalMessage({
-            to: deviceJid,
-            plaintext,
-            type: 'protocol',
-            category: 'peer',
-            pushPriority: 'high'
-        });
-    };
     const requestKeys = async (keyIds) => {
         requireCurrentIdentity('requestKeys');
         const normalizedKeyIds = [];

package/dist/client/messaging/link-preview.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLinkPreview = resolveLinkPreview;
+const node_fs_1 = require("node:fs");
+const media_1 = require("../media");
+const constants_1 = require("../../media/constants");
+const WaMediaCrypto_1 = require("../../media/crypto/WaMediaCrypto");
+const detect_1 = require("../../message/addons/link-preview/detect");
+const _proto_1 = require("../../proto.js");
+const primitives_1 = require("../../util/primitives");
+const INLINE_THUMBNAIL_MAX_BYTES = 64 * 1024;
+async function resolveLinkPreview(text, perMessage, deps) {
+    if (perMessage === false)
+        return null;
+    const globalEnabled = deps.options.enabled !== false;
+    if (!globalEnabled && perMessage === undefined)
+        return null;
+    let resolved;
+    if (typeof perMessage === 'object' && perMessage !== null) {
+        resolved = applyOverride(text, perMessage);
+        if (resolved === null)
+            return null;
+    }
+    else {
+        const detected = (0, detect_1.findFirstLink)(text);
+        if (detected === null)
+            return null;
+        resolved = await deps.fetcher.fetch({
+            url: detected.url,
+            matchedText: detected.matchedText,
+            logger: deps.logger
+        });
+        if (resolved === null)
+            return null;
+    }
+    const thumbnailFields = await resolveThumbnailFields(deps, resolved.thumbnail);
+    return { resolved, thumbnailFields };
+}
+function applyOverride(text, override) {
+    const matchedText = override.matchedText ?? (0, detect_1.findFirstLink)(text)?.matchedText;
+    if (matchedText === undefined || matchedText.length === 0)
+        return null;
+    return {
+        matchedText,
+        previewType: override.previewType ?? _proto_1.proto.Message.ExtendedTextMessage.PreviewType.NONE,
+        ...(override.title !== undefined ? { title: override.title } : {}),
+        ...(override.description !== undefined ? { description: override.description } : {}),
+        ...(override.thumbnail !== undefined ? { thumbnail: override.thumbnail } : {})
+    };
+}
+async function resolveThumbnailFields(deps, thumbnail) {
+    if (thumbnail === undefined)
+        return {};
+    if ('bytes' in thumbnail) {
+        return resolveBytesThumbnailFields(deps, thumbnail);
+    }
+    return resolveStreamThumbnailFields(deps, thumbnail);
+}
+async function resolveBytesThumbnailFields(deps, thumbnail) {
+    const fitsInline = thumbnail.bytes.byteLength <= INLINE_THUMBNAIL_MAX_BYTES;
+    const inlineFields = fitsInline ? buildInlineFields(thumbnail) : {};
+    if (deps.options.uploadHqThumbnail === false) {
+        return inlineFields;
+    }
+    try {
+        const hqFields = await uploadHqFromBytes(deps, thumbnail);
+        return { ...inlineFields, ...hqFields };
+    }
+    catch (error) {
+        deps.logger.warn('link preview thumbnail upload failed', {
+            message: (0, primitives_1.toError)(error).message
+        });
+        return inlineFields;
+    }
+}
+async function resolveStreamThumbnailFields(deps, thumbnail) {
+    if (deps.options.uploadHqThumbnail === false) {
+        thumbnail.stream.destroy();
+        return {};
+    }
+    try {
+        return await uploadHqFromStream(deps, thumbnail);
+    }
+    catch (error) {
+        deps.logger.warn('link preview thumbnail upload failed', {
+            message: (0, primitives_1.toError)(error).message
+        });
+        thumbnail.stream.destroy();
+        return {};
+    }
+}
+function buildInlineFields(thumbnail) {
+    return {
+        jpegThumbnail: thumbnail.bytes,
+        ...(thumbnail.width !== undefined ? { thumbnailWidth: thumbnail.width } : {}),
+        ...(thumbnail.height !== undefined ? { thumbnailHeight: thumbnail.height } : {})
+    };
+}
+async function uploadHqFromBytes(deps, thumbnail) {
+    const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
+    const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptBytes('thumbnail-link', mediaKey, thumbnail.bytes, { sidecar: false });
+    const directPath = await dispatchUpload(deps, encrypted.ciphertextHmac, encrypted.ciphertextHmac.byteLength, encrypted.fileEncSha256);
+    return {
+        thumbnailDirectPath: directPath,
+        thumbnailSha256: encrypted.fileSha256,
+        thumbnailEncSha256: encrypted.fileEncSha256,
+        mediaKey,
+        mediaKeyTimestamp: deps.serverClock.nowSeconds(),
+        ...(thumbnail.width !== undefined ? { thumbnailWidth: thumbnail.width } : {}),
+        ...(thumbnail.height !== undefined ? { thumbnailHeight: thumbnail.height } : {})
+    };
+}
+async function uploadHqFromStream(deps, thumbnail) {
+    const mediaKey = await WaMediaCrypto_1.WaMediaCrypto.generateMediaKey();
+    const encrypted = await WaMediaCrypto_1.WaMediaCrypto.encryptToFile('thumbnail-link', mediaKey, thumbnail.stream, { sidecar: false, expectedFileSize: thumbnail.contentLength });
+    let readStream;
+    try {
+        readStream = (0, node_fs_1.createReadStream)(encrypted.filePath);
+        const directPath = await dispatchUpload(deps, readStream, encrypted.fileSize, encrypted.fileEncSha256);
+        return {
+            thumbnailDirectPath: directPath,
+            thumbnailSha256: encrypted.fileSha256,
+            thumbnailEncSha256: encrypted.fileEncSha256,
+            mediaKey,
+            mediaKeyTimestamp: deps.serverClock.nowSeconds(),
+            ...(thumbnail.width !== undefined ? { thumbnailWidth: thumbnail.width } : {}),
+            ...(thumbnail.height !== undefined ? { thumbnailHeight: thumbnail.height } : {})
+        };
+    }
+    finally {
+        if (readStream && !readStream.closed) {
+            await new Promise((resolve) => {
+                readStream.once('close', resolve);
+                readStream.destroy();
+            });
+        }
+        await WaMediaCrypto_1.WaMediaCrypto.cleanupEncryptedFile(encrypted.filePath);
+    }
+}
+async function dispatchUpload(deps, body, contentLength, fileEncSha256) {
+    const mediaConn = await deps.getMediaConn();
+    const host = (0, media_1.selectMediaUploadHost)(mediaConn);
+    const uploadUrl = (0, media_1.buildMediaUploadUrl)(host, constants_1.MEDIA_UPLOAD_PATHS['thumbnail-link'], mediaConn.auth, fileEncSha256);
+    deps.logger.debug('uploading link preview thumbnail', { host, contentLength });
+    const response = await deps.mediaTransfer.uploadStream({
+        url: uploadUrl,
+        method: 'POST',
+        body,
+        contentLength,
+        contentType: 'image/jpeg'
+    });
+    const responseBody = await deps.mediaTransfer.readResponseBytes(response);
+    (0, media_1.assertMediaUploadStatus)(response.status, 'thumbnail-link upload');
+    const parsed = (0, media_1.parseMediaUploadJsonBody)(responseBody, 'thumbnail-link upload');
+    if (!parsed.direct_path) {
+        throw new Error('thumbnail-link upload response missing direct_path');
+    }
+    return parsed.direct_path;
+}