morok-bot-sdk 1.0.1

package/dist/flow/receive.js

@@ -0,0 +1,773 @@
+import { TextDecoder } from 'node:util';
+import { downloadAttachment, isEncryptedFileRef, parseGalleryItem, GALLERY_MIN_ITEMS, GALLERY_MAX_ITEMS, } from './attachments.js';
+const PEER_CACHE_TTL_MS = 5 * 60 * 1000;
+const DEDUP_MAX_ENTRIES = 1024;
+const DEDUP_TTL_MS = 5 * 60 * 1000;
+const BACKFILL_REQ_THROTTLE_MS = 5_000;
+const BACKFILL_REQ_THROTTLE_MAX = 4096;
+class DedupCache {
+    entries = new Map();
+    has(key) {
+        const at = this.entries.get(key);
+        if (at === undefined)
+            return false;
+        if (Date.now() - at > DEDUP_TTL_MS) {
+            this.entries.delete(key);
+            return false;
+        }
+        return true;
+    }
+    record(key) {
+        if (this.entries.size >= DEDUP_MAX_ENTRIES) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest !== undefined)
+                this.entries.delete(oldest);
+        }
+        this.entries.set(key, Date.now());
+    }
+}
+const PEER_CACHE_MAX = 1024;
+export class ReceiveFlow {
+    botUserId;
+    http;
+    ws;
+    signal;
+    convCache;
+    emitter;
+    groups;
+    opts;
+    logger;
+    peerCache = new Map();
+    dedup = new DedupCache();
+    textDec = new TextDecoder('utf-8', { fatal: false });
+    backfillReqThrottle = new Map();
+    constructor(botUserId, http, ws, signal, convCache, emitter, groups, opts, logger) {
+        this.botUserId = botUserId;
+        this.http = http;
+        this.ws = ws;
+        this.signal = signal;
+        this.convCache = convCache;
+        this.emitter = emitter;
+        this.groups = groups;
+        this.opts = opts;
+        this.logger = logger;
+        this.ws.on('frame', (frame) => {
+            void this.onFrame(frame).catch(err => {
+                this.logger?.warn({ err: err.message, frameType: frame.type }, '[receive] frame handler threw');
+                this.emitter.emit({ kind: 'error', error: err });
+            });
+        });
+    }
+    async onFrame(frame) {
+        switch (frame.type) {
+            case 'message': return this.onMessageFrame(frame);
+            case 'bot_started': return this.onBotStartedFrame(frame);
+            case 'bot_stopped': return this.onBotStoppedFrame(frame);
+            case 'conversation_added': return this.onConversationAddedFrame(frame);
+            case 'conversation_kicked': return this.onConversationKickedFrame(frame);
+            case 'channel_key_rotated': return this.onChannelKeyRotatedFrame(frame);
+            case 'channel_key_backfill_request': return this.onChannelKeyBackfillRequestFrame(frame);
+            case 'member_count_changed': return this.onMemberCountChangedFrame(frame);
+            case 'member_updated': return this.onMemberUpdatedFrame(frame);
+            case 'group_updated': return this.onGroupUpdatedFrame(frame);
+            case 'reaction_encrypted': return this.onReactionEncryptedFrame(frame);
+            case 'reaction_removed': return this.onReactionRemovedFrame(frame);
+            default: return;
+        }
+    }
+    async onMessageFrame(frame) {
+        const senderId = frame.senderId;
+        const messageType = frame.messageType;
+        if (typeof senderId === 'number' && senderId === this.botUserId) {
+            return;
+        }
+        if (messageType === 8)
+            return this.onGroupInbound(frame);
+        if (messageType !== 1 && messageType !== 3) {
+            this.logger?.debug({ messageType }, '[receive] skipping non-DM message');
+            return;
+        }
+        return this.onDirectInbound(frame);
+    }
+    async onDirectInbound(frame) {
+        const senderId = frame.senderId;
+        const recipientId = frame.recipientId;
+        const messageType = frame.messageType;
+        const ciphertext = frame.ciphertext;
+        if (typeof senderId !== 'number'
+            || typeof ciphertext !== 'string'
+            || typeof frame.senderDeviceId !== 'number'
+            || typeof frame.id !== 'number'
+            || typeof frame.conversationId !== 'number'
+            || (messageType !== 1 && messageType !== 3)) {
+            this.logger?.warn({ frame }, '[receive] malformed message frame');
+            return;
+        }
+        if (typeof recipientId === 'number' && recipientId !== this.botUserId) {
+            this.logger?.debug({ recipientId, botUserId: this.botUserId }, '[receive] message not for us');
+            return;
+        }
+        const clientMsgId = typeof frame.clientMsgId === 'string' ? frame.clientMsgId : null;
+        const dedupKey = clientMsgId !== null
+            ? `c:${senderId}.${frame.senderDeviceId}:${frame.conversationId}:${clientMsgId}`
+            : `s:${senderId}.${frame.senderDeviceId}:${frame.conversationId}:${frame.id}`;
+        if (dedupKey && this.dedup.has(dedupKey)) {
+            this.logger?.debug({ messageId: frame.id, clientMsgId }, '[receive] deduped replay');
+            return;
+        }
+        const senderDeviceId = frame.senderDeviceId;
+        let plaintextBytes;
+        try {
+            plaintextBytes = await this.signal.withPeerLock(senderId, senderDeviceId, () => this.signal.decrypt(senderId, senderDeviceId, messageType, ciphertext));
+        }
+        catch (err) {
+            this.logger?.warn({ err: err.message, senderId, deviceId: frame.senderDeviceId, messageType }, '[receive] decrypt failed');
+            this.emitter.emit({
+                kind: 'error',
+                error: new Error(`decrypt failed for senderId=${senderId}.${frame.senderDeviceId} type=${messageType}: ${err.message}`),
+            });
+            return;
+        }
+        if (dedupKey)
+            this.dedup.record(dedupKey);
+        const decoded = this.textDec.decode(plaintextBytes);
+        const action = parseBotAction(decoded);
+        if (action) {
+            const actionPeer = await this.resolvePeer(senderId).catch(() => null);
+            this.emitter.emit({
+                kind: 'control',
+                payload: {
+                    controlId: action.controlId,
+                    sender: actionPeer ?? { userId: senderId, username: `user_${senderId}`, displayName: null },
+                    conversationId: frame.conversationId,
+                    conversationType: 'DIRECT',
+                },
+            });
+            return;
+        }
+        const sniffed = sniffStructuredPayload(decoded);
+        const text = sniffed?.caption ?? (sniffed === null ? decoded : '');
+        const attachment = sniffed?.attachment;
+        const peer = await this.resolvePeer(senderId).catch(() => null);
+        if (!peer) {
+            this.logger?.warn({ senderId }, '[receive] peer resolution failed; emitting with stub');
+        }
+        const createdAt = typeof frame.createdAt === 'string'
+            ? new Date(frame.createdAt)
+            : new Date();
+        let attachmentObj;
+        let galleryObj;
+        if (attachment) {
+            attachmentObj = buildIncomingAttachment(attachment, () => downloadAttachment(this.http, attachment.ref, this.logger));
+        }
+        else if (sniffed?.gallery) {
+            galleryObj = buildIncomingGallery(sniffed.gallery, (ref) => () => downloadAttachment(this.http, ref, this.logger));
+        }
+        const baseMsg = {
+            messageId: frame.id,
+            conversationId: frame.conversationId,
+            conversationType: 'DIRECT',
+            sender: peer ?? { userId: senderId, username: `user_${senderId}`, displayName: null },
+            senderDeviceId: frame.senderDeviceId,
+            text,
+            ...(attachmentObj ? { attachment: attachmentObj } : {}),
+            ...(galleryObj ? { gallery: galleryObj } : {}),
+            clientMsgId,
+            replyToId: typeof frame.replyToId === 'number' ? frame.replyToId : null,
+            threadRootId: typeof frame.threadRootId === 'number' ? frame.threadRootId : null,
+            createdAt,
+        };
+        const parsed = parseCommand(text);
+        if (parsed) {
+            const cmd = {
+                ...baseMsg,
+                command: parsed.command,
+                args: parsed.args,
+                argv: parsed.argv,
+            };
+            this.emitter.emit({ kind: 'command', payload: cmd });
+            return;
+        }
+        this.emitter.emit({ kind: 'message', payload: baseMsg });
+    }
+    async onBotStartedFrame(frame) {
+        const userId = frame.userId;
+        const botUserId = frame.botUserId;
+        const startedAt = frame.startedAt;
+        if (typeof userId !== 'number' || (typeof botUserId === 'number' && botUserId !== this.botUserId)) {
+            this.logger?.warn({ frame }, '[receive] malformed bot_started');
+            return;
+        }
+        const peer = await this.resolvePeer(userId).catch(() => null);
+        const startedAtDate = typeof startedAt === 'string' ? new Date(startedAt) : new Date();
+        this.emitter.emit({
+            kind: 'start',
+            payload: {
+                peer: peer ?? { userId, username: `user_${userId}`, displayName: null },
+                startedAt: startedAtDate,
+            },
+        });
+    }
+    async onBotStoppedFrame(frame) {
+        const userId = frame.userId;
+        const botUserId = frame.botUserId;
+        const stoppedAt = frame.stoppedAt;
+        if (typeof userId !== 'number' || (typeof botUserId === 'number' && botUserId !== this.botUserId)) {
+            this.logger?.warn({ frame }, '[receive] malformed bot_stopped');
+            return;
+        }
+        this.peerCache.delete(userId);
+        const peer = await this.resolvePeer(userId).catch(() => null);
+        const stoppedAtDate = typeof stoppedAt === 'string' ? new Date(stoppedAt) : new Date();
+        this.emitter.emit({
+            kind: 'stop',
+            payload: {
+                peer: peer ?? { userId, username: `user_${userId}`, displayName: null },
+                stoppedAt: stoppedAtDate,
+            },
+        });
+    }
+    async onReactionEncryptedFrame(frame) {
+        const reactorId = frame.reactorUserId;
+        const reactorDevice = frame.reactorDeviceId;
+        const messageId = frame.messageId;
+        const messageType = frame.messageType;
+        const ciphertext = frame.ciphertext;
+        const conversationId = frame.conversationId;
+        const clientMsgId = typeof frame.clientMsgId === 'string' ? frame.clientMsgId : null;
+        if (typeof reactorId !== 'number'
+            || typeof reactorDevice !== 'number'
+            || typeof messageId !== 'number'
+            || typeof messageType !== 'number'
+            || typeof ciphertext !== 'string') {
+            this.logger?.warn({ frame }, '[receive] malformed reaction_encrypted');
+            return;
+        }
+        if (reactorId === this.botUserId)
+            return;
+        let unicode = null;
+        try {
+            let plaintext;
+            if (messageType === 8) {
+                if (!this.groups || typeof conversationId !== 'number') {
+                    this.logger?.debug({ messageId }, '[receive] group reaction dropped: no GroupsFlow / convId');
+                    return;
+                }
+                plaintext = await this.groups.decryptGroupMessage(conversationId, ciphertext);
+            }
+            else if (messageType === 1 || messageType === 3) {
+                plaintext = await this.signal.withPeerLock(reactorId, reactorDevice, () => this.signal.decrypt(reactorId, reactorDevice, messageType, ciphertext));
+            }
+            else {
+                return;
+            }
+            unicode = parseReactionUnicode(this.textDec.decode(plaintext));
+        }
+        catch (err) {
+            this.logger?.warn({ messageId, reactorId, messageType, err: err.message }, '[receive] reaction decrypt failed; emitting with unicode=null');
+        }
+        const peer = await this.resolvePeer(reactorId).catch(() => null);
+        this.emitter.emit({
+            kind: 'reaction',
+            payload: {
+                messageId,
+                clientMsgId,
+                reactor: peer ?? { userId: reactorId, username: `user_${reactorId}`, displayName: null },
+                unicode,
+                added: true,
+            },
+        });
+    }
+    async onReactionRemovedFrame(frame) {
+        const reactorId = frame.reactorUserId;
+        const messageId = frame.messageId;
+        const clientMsgId = typeof frame.clientMsgId === 'string' ? frame.clientMsgId : null;
+        if (typeof reactorId !== 'number' || typeof messageId !== 'number') {
+            this.logger?.warn({ frame }, '[receive] malformed reaction_removed');
+            return;
+        }
+        if (reactorId === this.botUserId)
+            return;
+        const peer = await this.resolvePeer(reactorId).catch(() => null);
+        this.emitter.emit({
+            kind: 'reaction',
+            payload: {
+                messageId,
+                clientMsgId,
+                reactor: peer ?? { userId: reactorId, username: `user_${reactorId}`, displayName: null },
+                unicode: null,
+                added: false,
+            },
+        });
+    }
+    async onGroupInbound(frame) {
+        if (!this.groups) {
+            this.logger?.debug({ messageType: frame.messageType }, '[receive] group-message dropped: GroupsFlow not wired');
+            return;
+        }
+        const senderId = frame.senderId;
+        const senderDeviceId = frame.senderDeviceId;
+        const conversationId = frame.conversationId;
+        const ciphertext = frame.ciphertext;
+        const messageId = frame.id;
+        const clientMsgId = typeof frame.clientMsgId === 'string' ? frame.clientMsgId : null;
+        if (typeof senderId !== 'number'
+            || typeof senderDeviceId !== 'number'
+            || typeof conversationId !== 'number'
+            || typeof ciphertext !== 'string'
+            || typeof messageId !== 'number') {
+            this.logger?.warn({ frame }, '[receive] malformed group-chat/channel frame');
+            return;
+        }
+        const dedupKey = clientMsgId !== null
+            ? `c:${senderId}.${senderDeviceId}:${conversationId}:${clientMsgId}`
+            : `s:${senderId}.${senderDeviceId}:${conversationId}:${messageId}`;
+        if (dedupKey && this.dedup.has(dedupKey)) {
+            this.logger?.debug({ messageId, clientMsgId }, '[receive] deduped group replay');
+            return;
+        }
+        let plaintextBytes;
+        try {
+            plaintextBytes = await this.groups.decryptGroupMessage(conversationId, ciphertext);
+        }
+        catch (err) {
+            this.logger?.warn({
+                conversationId, senderId, senderDeviceId,
+                err: err.message,
+            }, '[receive] group_message decrypt failed');
+            this.emitter.emit({
+                kind: 'error',
+                error: new Error(`group decrypt failed for conv=${conversationId} msg=${messageId}: ${err.message}`),
+            });
+            return;
+        }
+        if (dedupKey)
+            this.dedup.record(dedupKey);
+        let conversationType = 'GROUP';
+        if (this.convCache) {
+            const info = this.convCache.peek(conversationId)
+                ?? await this.convCache.load(conversationId).catch(() => null);
+            if (info && info.isChannel)
+                conversationType = 'CHANNEL';
+        }
+        const decoded = this.textDec.decode(plaintextBytes);
+        const sniffed = sniffStructuredPayload(decoded);
+        const text = sniffed?.caption ?? (sniffed === null ? decoded : '');
+        const attachment = sniffed?.attachment;
+        const peer = await this.resolvePeer(senderId).catch(() => null);
+        if (!peer) {
+            this.logger?.warn({ senderId }, '[receive] peer resolution failed; emitting with stub');
+        }
+        const createdAt = typeof frame.createdAt === 'string'
+            ? new Date(frame.createdAt)
+            : new Date();
+        let attachmentObj;
+        let galleryObj;
+        if (attachment) {
+            attachmentObj = buildIncomingAttachment(attachment, () => downloadAttachment(this.http, attachment.ref, this.logger));
+        }
+        else if (sniffed?.gallery) {
+            galleryObj = buildIncomingGallery(sniffed.gallery, (ref) => () => downloadAttachment(this.http, ref, this.logger));
+        }
+        const baseMsg = {
+            messageId: messageId,
+            conversationId: conversationId,
+            conversationType,
+            sender: peer ?? { userId: senderId, username: `user_${senderId}`, displayName: null },
+            senderDeviceId: senderDeviceId,
+            text,
+            ...(attachmentObj ? { attachment: attachmentObj } : {}),
+            ...(galleryObj ? { gallery: galleryObj } : {}),
+            clientMsgId,
+            replyToId: typeof frame.replyToId === 'number' ? frame.replyToId : null,
+            threadRootId: typeof frame.threadRootId === 'number' ? frame.threadRootId : null,
+            createdAt,
+        };
+        const parsed = parseCommand(text);
+        if (parsed) {
+            const cmd = {
+                ...baseMsg,
+                command: parsed.command,
+                args: parsed.args,
+                argv: parsed.argv,
+            };
+            this.emitter.emit({ kind: 'command', payload: cmd });
+            return;
+        }
+        this.emitter.emit({ kind: 'message', payload: baseMsg });
+    }
+    async onConversationAddedFrame(frame) {
+        if (!this.groups)
+            return;
+        const conversationId = frame.conversationId;
+        const conv = frame.conversation;
+        if (typeof conversationId !== 'number' || !conv || typeof conv.id !== 'number') {
+            this.logger?.warn({ frame }, '[receive] malformed conversation_added');
+            return;
+        }
+        const isChannel = conv.isChannel === true;
+        const isGroup = conv.isGroup === true || isChannel;
+        if (!isGroup)
+            return;
+        await this.groups.installGroupSecret(conversationId).catch(err => {
+            this.logger?.warn({ conversationId, err: err.message }, '[receive] group_secret install on conversation_added failed');
+        });
+        await Promise.all([
+            this.groups.installFromServer(conversationId, { sinceEpoch: -1 }).catch(err => {
+                this.logger?.warn({ conversationId, err: err.message }, '[receive] channel-key install on conversation_added failed');
+            }),
+            this.convCache?.load(conversationId).catch(err => {
+                this.logger?.warn({ conversationId, err: err.message }, '[receive] conv-cache load on conversation_added failed');
+            }) ?? Promise.resolve(),
+        ]);
+        const addedAtStr = frame.addedAt;
+        const addedAtDate = typeof addedAtStr === 'string' ? new Date(addedAtStr) : new Date();
+        this.emitter.emit({
+            kind: 'conversation_added',
+            payload: {
+                conversationId,
+                conversationType: isChannel ? 'CHANNEL' : 'GROUP',
+                title: typeof conv.title === 'string' ? conv.title : null,
+                addedAt: addedAtDate,
+            },
+        });
+    }
+    async onConversationKickedFrame(frame) {
+        const conversationId = frame.conversationId;
+        const reasonStr = frame.reason;
+        const actor = frame.actorUserId;
+        if (typeof conversationId !== 'number') {
+            this.logger?.warn({ frame }, '[receive] malformed conversation_kicked');
+            return;
+        }
+        const reason = reasonStr === 'left' ? 'left' : 'kicked';
+        if (this.groups) {
+            try {
+                await this.groups.forgetConversation(conversationId);
+            }
+            catch (err) {
+                this.logger?.warn({ conversationId, err: err.message }, '[receive] forgetConversation failed');
+            }
+        }
+        this.convCache?.drop(conversationId);
+        this.emitter.emit({
+            kind: 'conversation_kicked',
+            payload: {
+                conversationId,
+                reason,
+                actorUserId: typeof actor === 'number' ? actor : null,
+                removedAt: new Date(),
+            },
+        });
+    }
+    onMemberUpdatedFrame(frame) {
+        const conversationId = frame.conversationId;
+        if (typeof conversationId !== 'number')
+            return;
+        const memberUserId = frame.memberUserId;
+        if (typeof memberUserId !== 'number' || memberUserId !== this.botUserId)
+            return;
+        this.convCache?.invalidate(conversationId);
+    }
+    onGroupUpdatedFrame(frame) {
+        const conversationId = frame.conversationId;
+        if (typeof conversationId !== 'number')
+            return;
+        this.convCache?.invalidate(conversationId);
+    }
+    async onMemberCountChangedFrame(frame) {
+        const conversationId = frame.conversationId;
+        if (typeof conversationId !== 'number')
+            return;
+        this.convCache?.invalidate(conversationId);
+        if (!this.opts.autoBackfillOnJoin)
+            return;
+        if (!this.groups)
+            return;
+        const change = frame.change;
+        if (!change || change.kind !== 'added')
+            return;
+        if (typeof change.userId !== 'number' || change.userId === this.botUserId)
+            return;
+        const newUserId = change.userId;
+        const groups = this.groups;
+        const p = groups.backfillChannelKeys(conversationId, { userId: newUserId })
+            .then(({ accepted }) => {
+            this.logger?.info({ conversationId, newUserId, accepted }, '[receive] auto-backfill on join complete');
+        })
+            .catch((err) => {
+            this.logger?.warn({
+                conversationId, newUserId,
+                err: err.message,
+            }, '[receive] auto-backfill on join failed');
+            this.emitter.emit({
+                kind: 'error',
+                error: new Error(`auto-backfill failed for conv=${conversationId} user=${newUserId}: ${err.message}`),
+            });
+        });
+        groups.trackBackfill(p);
+    }
+    async onChannelKeyBackfillRequestFrame(frame) {
+        if (!this.opts.serveBackfillRequests)
+            return;
+        if (!this.groups)
+            return;
+        const conversationId = frame.conversationId;
+        const recipientUserId = frame.recipientUserId;
+        const recipientDeviceId = frame.recipientDeviceId;
+        if (typeof conversationId !== 'number'
+            || typeof recipientUserId !== 'number'
+            || typeof recipientDeviceId !== 'number') {
+            this.logger?.warn({ frame }, '[receive] malformed channel_key_backfill_request');
+            return;
+        }
+        if (recipientUserId === this.botUserId)
+            return;
+        const key = `${conversationId}:${recipientUserId}:${recipientDeviceId}`;
+        const now = Date.now();
+        const last = this.backfillReqThrottle.get(key);
+        if (last !== undefined && now - last < BACKFILL_REQ_THROTTLE_MS) {
+            this.logger?.debug({ conversationId, recipientUserId, recipientDeviceId }, '[receive] channel_key_backfill_request throttled');
+            return;
+        }
+        this.pruneBackfillThrottle(now);
+        this.backfillReqThrottle.set(key, now);
+        const groups = this.groups;
+        const p = groups.backfillChannelKeys(conversationId, { userId: recipientUserId, deviceIds: [recipientDeviceId] })
+            .then(({ accepted }) => {
+            this.logger?.info({ conversationId, recipientUserId, recipientDeviceId, accepted }, '[receive] served channel_key_backfill_request');
+        })
+            .catch((err) => {
+            this.logger?.warn({
+                conversationId, recipientUserId, recipientDeviceId,
+                err: err.message,
+            }, '[receive] channel_key_backfill_request: backfill failed');
+            this.emitter.emit({
+                kind: 'error',
+                error: new Error(`backfill_request failed for conv=${conversationId} ` +
+                    `user=${recipientUserId}.${recipientDeviceId}: ${err.message}`),
+            });
+        });
+        groups.trackBackfill(p);
+    }
+    pruneBackfillThrottle(now) {
+        if (this.backfillReqThrottle.size < BACKFILL_REQ_THROTTLE_MAX)
+            return;
+        for (const [k, t] of this.backfillReqThrottle) {
+            if (now - t >= BACKFILL_REQ_THROTTLE_MS)
+                this.backfillReqThrottle.delete(k);
+        }
+        while (this.backfillReqThrottle.size >= BACKFILL_REQ_THROTTLE_MAX) {
+            const oldest = this.backfillReqThrottle.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.backfillReqThrottle.delete(oldest);
+        }
+    }
+    async onChannelKeyRotatedFrame(frame) {
+        if (!this.groups)
+            return;
+        const conversationId = frame.conversationId;
+        const epoch = frame.epoch;
+        if (typeof conversationId !== 'number' || typeof epoch !== 'number') {
+            this.logger?.warn({ frame }, '[receive] malformed channel_key_rotated');
+            return;
+        }
+        try {
+            await this.groups.installFromServer(conversationId, {
+                sinceEpoch: Math.max(-1, epoch - 1),
+            });
+        }
+        catch (err) {
+            this.logger?.warn({ conversationId, epoch, err: err.message }, '[receive] channel-key install on rotation failed');
+        }
+    }
+    async resolvePeer(userId) {
+        const cached = this.peerCache.get(userId);
+        if (cached && Date.now() - cached.fetched < PEER_CACHE_TTL_MS) {
+            return cached.peer;
+        }
+        const res = await this.http.get(`/users/id/${userId}`);
+        const u = res.data.user;
+        const peer = {
+            userId: u.id,
+            username: u.username,
+            displayName: u.displayName,
+        };
+        this.peerCache.set(userId, { peer, fetched: Date.now() });
+        while (this.peerCache.size > PEER_CACHE_MAX) {
+            const oldest = this.peerCache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.peerCache.delete(oldest);
+        }
+        return peer;
+    }
+}
+function parseReactionUnicode(plaintext) {
+    if (plaintext.length === 0 || plaintext.length > 512)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(plaintext);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const e = parsed.emoji;
+    return typeof e === 'string' && e.length > 0 && e.length <= 64 ? e : null;
+}
+const COMMAND_LINE_RE = /^\/([a-z][a-z0-9_]{0,31})(?:\s+([\s\S]*))?$/;
+function parseCommand(text) {
+    if (text.includes('\n'))
+        return null;
+    const m = COMMAND_LINE_RE.exec(text.trim());
+    if (!m)
+        return null;
+    const args = (m[2] ?? '').trim();
+    const argv = args.length === 0 ? [] : args.split(/\s+/);
+    return { command: m[1], args, argv };
+}
+export const _parseCommand = parseCommand;
+export const _parseReactionUnicode = parseReactionUnicode;
+function sniffStructuredPayload(plaintext) {
+    if (plaintext.length === 0 || plaintext.charCodeAt(0) !== 0x7b) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(plaintext);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const p = parsed;
+    const type = p.type;
+    if (type === 'file') {
+        if (!isEncryptedFileRef(p.ref))
+            return null;
+        const caption = typeof p.caption === 'string' ? p.caption : '';
+        return {
+            caption,
+            attachment: { kind: 'file', ref: p.ref },
+        };
+    }
+    if (type === 'voice') {
+        if (!isEncryptedFileRef(p.ref))
+            return null;
+        const duration = typeof p.duration === 'number' && isFinite(p.duration) && p.duration > 0
+            ? Math.min(p.duration, 600) : 0;
+        const waveform = Array.isArray(p.waveform)
+            ? p.waveform
+                .filter((n) => typeof n === 'number' && isFinite(n))
+                .slice(0, 64)
+                .map(n => {
+                const v = Math.round(n);
+                return v < 0 ? 0 : v > 100 ? 100 : v;
+            })
+            : [];
+        return {
+            attachment: { kind: 'voice', ref: p.ref, duration, waveform },
+        };
+    }
+    if (type === 'video_note') {
+        if (!isEncryptedFileRef(p.ref))
+            return null;
+        const duration = typeof p.duration === 'number' && isFinite(p.duration) && p.duration > 0
+            ? Math.min(p.duration, 300) : 0;
+        const shape = (typeof p.shape === 'string' && /^[a-zA-Z0-9]{1,32}$/.test(p.shape))
+            ? p.shape
+            : 'circle';
+        return {
+            attachment: { kind: 'video_note', ref: p.ref, duration, shape },
+        };
+    }
+    if (type === 'gallery') {
+        if (!Array.isArray(p.items))
+            return null;
+        const items = [];
+        for (const raw of p.items) {
+            const it = parseGalleryItem(raw);
+            if (it)
+                items.push(it);
+        }
+        if (items.length < GALLERY_MIN_ITEMS)
+            return null;
+        if (items.length > GALLERY_MAX_ITEMS) {
+            items.length = GALLERY_MAX_ITEMS;
+        }
+        const caption = typeof p.caption === 'string' ? p.caption : '';
+        return {
+            caption,
+            gallery: { items },
+        };
+    }
+    return null;
+}
+function buildIncomingAttachment(parsed, download) {
+    const base = {
+        kind: parsed.kind,
+        fileId: parsed.ref.fileId,
+        sha256: parsed.ref.sha256,
+        mime: parsed.ref.mime,
+        size: parsed.ref.size,
+        name: parsed.ref.name ?? null,
+        virusTotalVerdict: null,
+        download,
+    };
+    if (parsed.duration !== undefined)
+        base.duration = parsed.duration;
+    if (parsed.waveform !== undefined)
+        base.waveform = parsed.waveform;
+    if (parsed.shape !== undefined)
+        base.shape = parsed.shape;
+    return base;
+}
+function buildIncomingGallery(parsed, makeDownload) {
+    const items = parsed.items.map(it => {
+        if (it.type === 'file') {
+            const fileAtt = { kind: 'file', ref: it.ref };
+            return { kind: 'file', attachment: buildIncomingAttachment(fileAtt, makeDownload(it.ref)) };
+        }
+        if (it.type === 'contact') {
+            const out = { kind: 'contact', userId: it.userId };
+            if (it.username !== undefined)
+                out.username = it.username;
+            if (it.displayName !== undefined)
+                out.displayName = it.displayName;
+            if (it.avatarUrl !== undefined)
+                out.avatarUrl = it.avatarUrl;
+            if (it.avatarEmoji !== undefined)
+                out.avatarUnicode = it.avatarEmoji;
+            return out;
+        }
+        return { kind: 'location', lat: it.lat, lng: it.lng };
+    });
+    return { items };
+}
+function parseBotAction(plaintext) {
+    if (plaintext.length === 0 || plaintext.charCodeAt(0) !== 0x7b)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(plaintext);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const p = parsed;
+    if (p.type !== 'morok_bot_action')
+        return null;
+    if (typeof p.controlId !== 'string' || p.controlId.length === 0)
+        return null;
+    return { controlId: p.controlId };
+}
+export const _sniffStructuredPayload = sniffStructuredPayload;
+export const _buildIncomingAttachment = buildIncomingAttachment;
+//# sourceMappingURL=receive.js.map