zapo-js 0.2.0 → 0.3.0

package/dist/client/coordinators/WaTrustedContactTokenCoordinator.js

@@ -14,24 +14,40 @@ class WaTrustedContactTokenCoordinator {
         this.store = options.store;
         this.runtime = options.runtime;
         const maxDurationS = options.maxDurationS ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.MAX_DURATION_S;
-        this.config = {
+        this.baseConfig = {
             durationS: (0, tc_token_1.clampDuration)(options.durationS ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.DURATION_S, maxDurationS),
             numBuckets: options.numBuckets ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.NUM_BUCKETS,
             senderDurationS: (0, tc_token_1.clampDuration)(options.senderDurationS ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.SENDER_DURATION_S, maxDurationS),
             senderNumBuckets: options.senderNumBuckets ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.SENDER_NUM_BUCKETS,
             maxDurationS
         };
+        this.getConfigOverrides = options.getConfigOverrides;
         this.csTokenGenerator = new cs_token_1.CsTokenGenerator();
         this.senderTokenDedup = new PromiseDedup_1.PromiseDedup();
         this.cachedNctSalt = null;
         this.nctSaltHydrated = false;
     }
+    resolveConfig() {
+        const overrides = this.getConfigOverrides?.();
+        if (!overrides) {
+            return this.baseConfig;
+        }
+        const maxDurationS = overrides.maxDurationS ?? this.baseConfig.maxDurationS;
+        return {
+            durationS: (0, tc_token_1.clampDuration)(overrides.durationS ?? this.baseConfig.durationS, maxDurationS),
+            numBuckets: overrides.numBuckets ?? this.baseConfig.numBuckets,
+            senderDurationS: (0, tc_token_1.clampDuration)(overrides.senderDurationS ?? this.baseConfig.senderDurationS, maxDurationS),
+            senderNumBuckets: overrides.senderNumBuckets ?? this.baseConfig.senderNumBuckets,
+            maxDurationS
+        };
+    }
     async resolveTokenForMessage(recipientJid) {
         const record = await this.store.getByJid(recipientJid);
         const nowS = Math.floor(Date.now() / 1000);
+        const config = this.resolveConfig();
         if (record?.tcToken &&
             record.tcTokenTimestamp !== undefined &&
-            !(0, tc_token_1.isTokenExpired)(record.tcTokenTimestamp, nowS, this.config.durationS, this.config.numBuckets)) {
+            !(0, tc_token_1.isTokenExpired)(record.tcTokenTimestamp, nowS, config.durationS, config.numBuckets)) {
             return (0, privacy_token_2.buildTcTokenMessageNode)(record.tcToken);
         }
         const nctSalt = await this.getNctSalt();
@@ -72,8 +88,9 @@ class WaTrustedContactTokenCoordinator {
             const nowS = Math.floor(Date.now() / 1000);
             const record = await this.store.getByJid(recipientJid);
             const senderTimestampS = record?.tcTokenSenderTimestamp;
+            const config = this.resolveConfig();
             if (senderTimestampS !== undefined && senderTimestampS > 0) {
-                if (!(0, tc_token_1.shouldSendNewToken)(senderTimestampS, nowS, this.config.senderDurationS)) {
+                if (!(0, tc_token_1.shouldSendNewToken)(senderTimestampS, nowS, config.senderDurationS)) {
                     return;
                 }
             }
@@ -91,7 +108,8 @@ class WaTrustedContactTokenCoordinator {
             return;
         }
         const nowS = Math.floor(Date.now() / 1000);
-        if ((0, tc_token_1.isTokenExpired)(record.tcTokenSenderTimestamp, nowS, this.config.senderDurationS, this.config.senderNumBuckets)) {
+        const config = this.resolveConfig();
+        if ((0, tc_token_1.isTokenExpired)(record.tcTokenSenderTimestamp, nowS, config.senderDurationS, config.senderNumBuckets)) {
             return;
         }
         try {

package/dist/client/dirty.js

@@ -266,7 +266,7 @@ async function clearDirtyBits(runtime, dirtyBits) {
     try {
         await runtime.queryWithContext('dirty.clear', (0, account_sync_1.buildClearDirtyBitsIq)(dirtyBits), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
-        });
+        }, { useSystemId: true });
         runtime.logger.info('dirty bits cleared', {
             count: dirtyBits.length
         });

package/dist/client/events/abprops.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAbPropsIqResult = parseAbPropsIqResult;
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+function parseAbPropsIqResult(node) {
+    const propsNode = (0, helpers_1.findNodeChild)(node, 'props');
+    if (!propsNode) {
+        return {
+            abKey: null,
+            hash: null,
+            refresh: null,
+            refreshId: null,
+            isDeltaUpdate: false,
+            props: []
+        };
+    }
+    const attrs = propsNode.attrs;
+    const propChildren = (0, helpers_1.getNodeChildren)(propsNode);
+    const props = [];
+    for (let i = 0; i < propChildren.length; i += 1) {
+        const child = propChildren[i];
+        if (child.tag !== 'prop') {
+            continue;
+        }
+        const configCode = (0, primitives_1.parseOptionalInt)(child.attrs.config_code);
+        if (configCode === undefined) {
+            continue;
+        }
+        props.push({
+            configCode,
+            configValue: child.attrs.config_value ?? null
+        });
+    }
+    return {
+        abKey: attrs.ab_key ?? null,
+        hash: attrs.hash ?? null,
+        refresh: (0, primitives_1.parseOptionalInt)(attrs.refresh) ?? null,
+        refreshId: (0, primitives_1.parseOptionalInt)(attrs.refresh_id) ?? null,
+        isDeltaUpdate: attrs.delta_update === 'true',
+        props
+    };
+}

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

@@ -3,7 +3,6 @@ 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);
@@ -31,7 +30,7 @@ function parsePrivacyTokenNotification(node) {
         }
         result[result.length] = {
             type,
-            tokenBytes: (0, bytes_1.toBytesView)(content),
+            tokenBytes: content,
             timestampS: (0, coercion_1.asNumber)(Number(rawTimestamp), 'privacy_token.t')
         };
     }

package/dist/client/events/registration.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRegistrationNotification = parseRegistrationNotification;
+const notification_1 = require("../../protocol/notification");
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+function parseRegistrationNotification(node) {
+    const firstChild = (0, helpers_1.getFirstNodeChild)(node);
+    if (!firstChild) {
+        return null;
+    }
+    if (firstChild.tag === notification_1.WA_REGISTRATION_NOTIFICATION_TAGS.WA_OLD_REGISTRATION) {
+        const code = firstChild.attrs.code;
+        const expirySeconds = (0, primitives_1.parseOptionalInt)(firstChild.attrs.expiry_t);
+        const fromDeviceId = firstChild.attrs.device_id;
+        if (!code || expirySeconds === undefined || !fromDeviceId) {
+            return null;
+        }
+        return {
+            kind: 'registration_code',
+            code,
+            expiryTimestampMs: expirySeconds * 1000,
+            fromDeviceId
+        };
+    }
+    if (firstChild.tag === notification_1.WA_REGISTRATION_NOTIFICATION_TAGS.DEVICE_LOGOUT) {
+        const serverToken = firstChild.attrs.id;
+        const tSeconds = (0, primitives_1.parseOptionalInt)(firstChild.attrs.t);
+        if (!serverToken || tSeconds === undefined) {
+            return null;
+        }
+        return {
+            kind: 'account_takeover_notice',
+            serverToken,
+            attemptTimestampMs: tSeconds * 1000,
+            newDeviceName: firstChild.attrs.device,
+            newDevicePlatform: firstChild.attrs.new_device_platform,
+            newDeviceAppVersion: firstChild.attrs.new_device_app_version
+        };
+    }
+    return null;
+}

package/dist/client/incoming.js

@@ -4,10 +4,12 @@ exports.createIncomingBaseEvent = createIncomingBaseEvent;
 exports.createIncomingReceiptHandler = createIncomingReceiptHandler;
 exports.createIncomingFailureHandler = createIncomingFailureHandler;
 exports.createIncomingNotificationHandler = createIncomingNotificationHandler;
+exports.createIncomingRegistrationNotificationHandler = createIncomingRegistrationNotificationHandler;
 exports.createIncomingGroupNotificationHandler = createIncomingGroupNotificationHandler;
 exports.createInfoBulletinNotificationEvent = createInfoBulletinNotificationEvent;
 exports.createUnhandledIncomingNodeEvent = createUnhandledIncomingNodeEvent;
 const group_1 = require("./events/group");
+const registration_1 = require("./events/registration");
 const constants_1 = require("../protocol/constants");
 const global_1 = require("../transport/node/builders/global");
 const helpers_1 = require("../transport/node/helpers");
@@ -226,6 +228,41 @@ function createIncomingNotificationHandler(options) {
         return true;
     };
 }
+function createIncomingRegistrationNotificationHandler(options) {
+    return async (node) => {
+        if (node.attrs.type !== constants_1.WA_NOTIFICATION_TYPES.REGISTRATION) {
+            return false;
+        }
+        const parsed = (0, registration_1.parseRegistrationNotification)(node);
+        if (!parsed) {
+            return false;
+        }
+        const baseEvent = createIncomingBaseEvent(node);
+        if (parsed.kind === 'registration_code') {
+            options.emitRegistrationCode({
+                ...baseEvent,
+                code: parsed.code,
+                expiryTimestampMs: parsed.expiryTimestampMs,
+                fromDeviceId: parsed.fromDeviceId
+            });
+        }
+        else {
+            options.emitAccountTakeoverNotice({
+                ...baseEvent,
+                serverToken: parsed.serverToken,
+                attemptTimestampMs: parsed.attemptTimestampMs,
+                newDeviceName: parsed.newDeviceName,
+                newDevicePlatform: parsed.newDevicePlatform,
+                newDeviceAppVersion: parsed.newDeviceAppVersion
+            });
+        }
+        await sendSafeAck(options.logger, options.sendNode, (0, global_1.buildAckNode)({
+            kind: 'notification',
+            node
+        }));
+        return true;
+    };
+}
 function createIncomingGroupNotificationHandler(options) {
     return async (node) => {
         if (node.attrs.type !== constants_1.WA_NOTIFICATION_TYPES.GROUP) {

package/dist/client/mailbox.js

@@ -1,6 +1,7 @@
 "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");
 function persistContacts(writeBehind, event, nowMs) {
@@ -17,7 +18,7 @@ function persistContacts(writeBehind, event, nowMs) {
     }
 }
 function persistIncomingMailboxEntities(options) {
-    const { logger, writeBehind, event } = options;
+    const { logger, writeBehind, messageSecretStore, event } = options;
     const { stanzaId, chatJid } = event;
     if (!stanzaId || !chatJid) {
         return;
@@ -39,6 +40,21 @@ function persistIncomingMailboxEntities(options) {
             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;
+}