@theotherwillembotha/node-red-whatsapp 0.0.55

package/build/whatsapp/service/WhatsappClient.js

@@ -0,0 +1,869 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatType = exports.GroupClient = exports.WhatsappClient = exports.ALBUM_TIMEOUT_MS = void 0;
+const baileys_1 = __importStar(require("baileys"));
+const uuid_1 = require("uuid");
+const node_cache_1 = __importDefault(require("node-cache"));
+const pino_1 = __importDefault(require("pino"));
+const WhatsappStore_1 = require("./WhatsappStore");
+const usePairingCode = false;
+const msgRetryCounterCache = new node_cache_1.default();
+exports.ALBUM_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour default
+class WhatsappClient {
+    constructor(config) {
+        this.onQRCodeListeners = [];
+        this.onConnectionSuccessListeners = [];
+        this.messageSubscribers = {};
+        this.groupClients = {};
+        this.pendingAlbums = new Map();
+        this.config = config;
+    }
+    clientConfig() {
+        return this.config;
+    }
+    details() {
+        //@ts-ignore
+        let userID = this.state.creds.me.id.replace(/:\d+(?=@)/, "");
+        return {
+            userID: userID,
+            msisdn: userID.substring(0, userID.indexOf("@"))
+        };
+    }
+    onQRCode(listener) {
+        this.onQRCodeListeners.push(listener);
+        // when someone subscribes to the qr code and there is a current active QR code, send it out.
+        if (this.currentQRCode) {
+            listener(this.currentQRCode);
+        }
+    }
+    groups() {
+        return this._groupService;
+    }
+    getGroupClient(groupId) {
+        let groupClient = this.groupClients[groupId];
+        if (!groupClient) {
+            this.groupClients[groupId] = groupClient = new GroupClient(this, groupId);
+        }
+        return groupClient;
+    }
+    subscribe(listener, filter) {
+        let subscriberID = (0, uuid_1.v4)();
+        filter = filter ? filter : {};
+        console.log("subscribe to whatsapp messages", filter);
+        this.messageSubscribers[subscriberID] = (message) => {
+            console.log("Received message: ", message);
+            if ((!filter.groupId || filter.groupId === message.chat.id) &&
+                (!filter.types || filter.types.length === 0 || filter.types.indexOf(message.type) > -1)) {
+                listener(message);
+            }
+        };
+        return subscriberID;
+    }
+    unsubscribe(subscriber) {
+        Object.entries(this.messageSubscribers)
+            .filter(([key, value]) => value === subscriber)
+            .forEach(([key, value]) => delete this.messageSubscribers[key]);
+    }
+    subscribers() {
+        return Object.values(this.messageSubscribers);
+    }
+    async sendMessage(chatId, message) {
+        let result;
+        if (message.image) {
+            // send image, with optional caption if text is provided
+            result = await this.socket.sendMessage(chatId, {
+                image: message.image,
+                caption: message.text
+            });
+        }
+        else if (message.text) {
+            // send text-only message
+            result = await this.socket.sendMessage(chatId, { text: message.text });
+        }
+        else {
+            throw new Error("Message must contain either text or image");
+        }
+        return { messageId: result.key.id };
+    }
+    onConnectionSuccess(listener) {
+        this.onConnectionSuccessListeners.push(listener);
+    }
+    async start() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        console.log("starting client", this.clientConfig());
+        this.logger = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` }, pino_1.default.destination(this.config.fileStorageRoot + '/wa-logs.txt'));
+        this.logger.level = 'trace';
+        // attempt to load the local config.
+        const { state, saveCreds } = await (0, baileys_1.useMultiFileAuthState)(this.config.fileStorageRoot + "/" + this.config.localConnectionId);
+        this.state = state;
+        this.saveCreds = saveCreds;
+        // fetch latest version of WA Web
+        const { version, isLatest } = await (0, baileys_1.fetchLatestBaileysVersion)();
+        console.log(`using WA v${version.join('.')}, isLatest: ${isLatest}`);
+        // before creating the connection, create / open the database.
+        this.store = await WhatsappStore_1.WhatsappStore.createStore(this.config.localConnectionId, this.config.fileStorageRoot + "/" + this.config.localConnectionId);
+        // create the websocket.
+        this.socket = (0, baileys_1.default)({
+            version: version,
+            logger: this.logger,
+            //printQRInTerminal: !usePairingCode,
+            auth: {
+                creds: state.creds,
+                keys: (0, baileys_1.makeCacheableSignalKeyStore)(state.keys, this.logger),
+            },
+            msgRetryCounterCache,
+            generateHighQualityLinkPreview: true,
+            // uncomment to avoid receiving historic messages.
+            //shouldSyncHistoryMessage:() => false,
+            //getMessage
+        });
+        // create the services.
+        this._groupService = new GroupService(this.socket, this.store, this.state);
+        console.log("bound socket to client", this.clientConfig());
+        // connection.
+        this.socket.ev.on('connection.update', this.connection_update.bind(this));
+        this.socket.ev.on('creds.update', this.saveCreds.bind(this));
+        // contacts
+        this.socket.ev.on('contacts.upsert', this.contacts_received.bind(this));
+        this.socket.ev.on('contacts.update', this.contacts_updated.bind(this));
+        // messages
+        this.socket.ev.on('messaging-history.set', this.messaging_history.bind(this));
+        this.socket.ev.on('messages.upsert', this.messages_upsert.bind(this));
+        this.socket.ev.on('messages.update', this.messages_update.bind(this));
+        // groups
+        this.socket.ev.on('groups.upsert', this.groups_upsert.bind(this));
+        this.socket.ev.on('group-participants.update', this.group_participants_update.bind(this));
+        this.socket.ev.on('group.member-tag.update', this.group_member_tag_update.bind(this));
+        // other.
+        this.socket.ev.on('labels.edit', this.doNothing.bind(this));
+        this.socket.ev.on('presence.update', this.doNothing.bind(this));
+        this.socket.ev.on('message-receipt.update', this.doNothing.bind(this));
+        // handle socket events.
+        this.socket.ev.process(
+        // events is a map for event name => event data
+        async (events) => {
+            if (events["connection.update"] ||
+                events["creds.update"] ||
+                events["messaging-history.set"] ||
+                events["messages.upsert"] ||
+                events["messages.update"] ||
+                events["labels.edit"] ||
+                events["presence.update"] ||
+                events["message-receipt.update"] ||
+                events["contacts.update"] ||
+                events["groups.upsert"] ||
+                events["group-participants.update"] ||
+                events["group.member-tag.update"]) {
+                return;
+            }
+            // just spill everything for now.
+            console.log("EVENT! ", JSON.stringify(events));
+        });
+        // start album cleanup timer (check every 5 minutes)
+        this.albumCleanupTimer = setInterval(() => this.cleanupTimedOutAlbums(), 5 * 60 * 1000);
+        //*/
+    }
+    async messages_upsert(upsert) {
+        if (upsert.type === 'notify') {
+            upsert.messages.forEach(message => this.message_received(message, true));
+        }
+        if (upsert.type === 'append') {
+            upsert.messages.forEach(message => this.message_received(message, true));
+        }
+    }
+    async messages_update(updates) {
+        for (const update of updates) {
+            const loc = update.update.message?.liveLocationMessage;
+            if (!loc)
+                continue;
+            const remoteJid = update.key.remoteJid;
+            const chat = await this.store.chats().get(remoteJid);
+            const whatsappmessage = {
+                timestamp: Date.now() / 1000,
+                messageId: update.key.id,
+                chat: {
+                    id: chat?.id ?? remoteJid,
+                    name: chat?.name ?? remoteJid,
+                },
+                sender: {
+                    id: update.key.participant ?? remoteJid,
+                    name: update.key.participant ?? remoteJid,
+                    me: !!update.key.fromMe,
+                },
+                type: WhatsappStore_1.MessageType.LiveLocation,
+                payload: {
+                    latitude: loc.degreesLatitude,
+                    longitude: loc.degreesLongitude,
+                    sequenceNumber: loc.sequenceNumber != null ? String(loc.sequenceNumber) : undefined,
+                },
+            };
+            Object.values(this.messageSubscribers).forEach(sub => sub(whatsappmessage));
+        }
+    }
+    async groups_upsert(groups) {
+        for (const group of groups) {
+            const chat = await this.store.chats().create(group.id, "", ChatType.Group, group.owner ?? "", group.subject, group.desc ?? "");
+            for (const participant of group.participants) {
+                const contactId = participant.phoneNumber ?? participant.id;
+                const contact = await this.store.contacts().get(contactId);
+                if (contact) {
+                    chat.addParticipant(contact, WAClientHelper.parseRole(participant.admin));
+                }
+            }
+            await this.store.chats().save(chat);
+        }
+    }
+    async group_participants_update(event) {
+        const groupId = event.id;
+        const myJid = this.state.creds.me.id.replace(/:\d+(?=@)/, "");
+        if (event.action === "remove") {
+            // check if the linked account itself was removed from the group.
+            const selfRemoved = event.participants.some(p => p.phoneNumber === myJid || p.id === myJid);
+            if (selfRemoved) {
+                console.log(`Linked account removed from group ${groupId} — deleting from store`);
+                await this.store.chats().delete(groupId);
+                return;
+            }
+            // remove other participants from the store.
+            const contactIds = event.participants.map(p => p.phoneNumber ?? p.id);
+            await this.store.chats().removeParticipants(groupId, contactIds);
+        }
+        else if (event.action === "add") {
+            // load with participants relation — without it, addParticipant() initialises a fresh
+            // empty array and orphanedRowAction:"delete" would wipe all existing members on save.
+            const chat = await this.store.chats().getWithParticipants(groupId);
+            if (chat) {
+                for (const participant of event.participants) {
+                    const contactId = participant.phoneNumber ?? participant.id;
+                    const contact = await this.store.contacts().get(contactId);
+                    if (contact) {
+                        chat.addParticipant(contact, WAClientHelper.parseRole(participant.admin));
+                    }
+                }
+                await this.store.chats().save(chat);
+            }
+        }
+        else if (event.action === "promote" || event.action === "demote") {
+            const role = event.action === "promote" ? WhatsappStore_1.Role.Admin : WhatsappStore_1.Role.Member;
+            for (const participant of event.participants) {
+                const contactId = participant.phoneNumber ?? participant.id;
+                await this.store.chats().updateParticipantRole(groupId, contactId, role);
+            }
+        }
+    }
+    async group_member_tag_update(event) {
+        const contactId = event.participantAlt ?? event.participant;
+        await this.store.chats().updateParticipantLabel(event.groupId, contactId, event.label);
+    }
+    async connection_update(update) {
+        if (update.connection === 'close') {
+            const statusCode = update.lastDisconnect?.error?.output?.statusCode;
+            if (statusCode === baileys_1.DisconnectReason.loggedOut) {
+                console.log(`WhatsApp [${this.config.localConnectionId}]: logged out.`);
+                return;
+            }
+            // restartRequired (515) is the normal post-QR-scan restart; use a shorter backoff.
+            // All other close reasons (network drop, WebSocket error, etc.) use a longer backoff.
+            const delayMs = statusCode === baileys_1.DisconnectReason.restartRequired ? 3000 : 5000;
+            this.scheduleReconnect(delayMs, statusCode);
+            return;
+        }
+        if (update.connection === 'open') {
+            console.log(`WhatsApp [${this.config.localConnectionId}]: connected.`);
+            this.onConnectionSuccessListeners.forEach(listener => listener());
+            // fetch recent message history on connect.
+            let count = 10;
+            let oldestMessageKey = {};
+            let oldestMessageTimestamp = new Date().getTime() - (10 * 24 * 60 * 1000);
+            this.socket.fetchMessageHistory(count, oldestMessageKey, oldestMessageTimestamp);
+        }
+        if (update.qr) {
+            // uncomment to render QRCode to console
+            // QRCode.toString(update.qr, {type:"terminal"}, function (err:any, imageString:any) {
+            //     if (err) throw err
+            //     console.log(imageString);
+            // })
+            this.currentQRCode = update.qr;
+            this.onQRCodeListeners.forEach(listener => listener(update.qr));
+        }
+    }
+    scheduleReconnect(delayMs, statusCode) {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        console.log(`WhatsApp [${this.config.localConnectionId}]: connection closed (code: ${statusCode}). Reconnecting in ${delayMs / 1000}s...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.start();
+        }, delayMs);
+    }
+    async stop() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.albumCleanupTimer) {
+            clearInterval(this.albumCleanupTimer);
+            this.albumCleanupTimer = undefined;
+        }
+        return this.socket.logout();
+    }
+    cleanupTimedOutAlbums() {
+        const now = Date.now();
+        for (const [chatId, album] of this.pendingAlbums) {
+            if (now - album.createdAt > exports.ALBUM_TIMEOUT_MS) {
+                console.log(`Album timeout: finalizing album ${album.albumMessageId} for chat ${chatId} (received ${album.receivedImages}/${album.expectedImages} images, ${album.receivedVideos}/${album.expectedVideos} videos)`);
+                this.pendingAlbums.delete(chatId);
+            }
+        }
+    }
+    async contacts_received(contacts) {
+        // sample { "id": "<phone>@s.whatsapp.net", "notify": "<name>" },
+        // sample { "id": "<groupid>@g.us", "name": "<group_name>" },
+        // sample { "id": "0@s.whatsapp.net", "name": "WhatsApp Business" },
+        // sample { "id": "<phone>@s.whatsapp.net", "phoneNumber": "<phone>@s.whatsapp.net", "verifiedName": "<business_name>" },
+        await Promise.all(contacts.map(async (newContact) => {
+            // find the contact by id.
+            if (newContact.id.endsWith("@lid")) {
+                console.log("contacts_received: FOUND Contact referenced by lid", newContact);
+            }
+            let contact = await this.store.contacts().get(newContact.id);
+            // update the phone number
+            if (newContact.phoneNumber) {
+                contact.phoneNumber = newContact.phoneNumber;
+            }
+            ;
+            // verified name > name > notify;
+            if (newContact.verifiedName) {
+                contact.name = newContact.verifiedName;
+            }
+            ;
+            if (newContact.name && !newContact.verifiedName) {
+                contact.name = newContact.name;
+            }
+            ;
+            if (newContact.notify && !newContact.name && !newContact.verifiedName) {
+                contact.name = newContact.name;
+            }
+            ;
+            // set the lid.
+            if (newContact.lid) {
+                contact.lid = newContact.lid;
+            }
+            ;
+            return this.store.contacts().save(contact);
+        }));
+    }
+    async contacts_updated(contacts) {
+        // sample 'contacts.update': [ { id: '94953791303764@lid', imgUrl: 'changed' } ]
+        console.log("Handle Contacts.Updated", JSON.stringify(contacts));
+    }
+    async messaging_history(history) {
+        if (history.contacts) {
+            await this.contacts_received(history.contacts);
+        }
+        if (history.chats) {
+            await this.chats_receieved(history.chats);
+        }
+        if (history.messages) {
+            await Promise.all(history.messages.map(async (message) => {
+                return this.message_received(message, false);
+            }));
+        }
+    }
+    async chats_receieved(chats) {
+        await Promise.all(chats.map(async (chat) => {
+            //console.log("new chat: ", JSON.stringify(chat));
+            let id = chat.id;
+            let type = (id.endsWith("@g.us")) ? ChatType.Group : ChatType.Conversation;
+            let lid = id.endsWith("@lid") ? id : "";
+            let persistedChat;
+            if (type === ChatType.Group) {
+                // fetch the chat / group metadata.
+                let metadata = await this.socket.groupMetadata(chat.id);
+                //console.log("CHAT GROUP METADATA", JSON.stringify(metadata, null, 2));
+                // persist the chat.
+                persistedChat = await this.store.chats().create(id, lid, type, metadata.owner, metadata.subject, metadata.desc);
+                for (let participant of metadata.participants) {
+                    if (participant.phoneNumber && participant.phoneNumber.endsWith("@lid")) {
+                        console.log("chats_receieved: FOUND Contact referenced by lid", participant.phoneNumber);
+                    }
+                    // the phone number will usually be included.
+                    let contact = await this.store.contacts().get(participant.phoneNumber);
+                    if (!contact) {
+                        console.log("contact " + participant.id + " not found for chat " + chat.id, metadata);
+                    }
+                    else {
+                        //console.log("adding participant ", persistedChat.id, participant);
+                        persistedChat.addParticipant(contact, WAClientHelper.parseRole(participant.admin));
+                    }
+                }
+                this.store.chats().save(persistedChat);
+            }
+            if (type === ChatType.Conversation) {
+                persistedChat = await this.store.chats().create(id, lid, type, "", "", "");
+                this.store.chats().save(persistedChat);
+            }
+            // after persisting the chat, check if it has some messages attached to it.
+            let messages = chat.messages ? chat.messages.map(message => message.message) : [];
+            return await Promise.all(messages.map(message => {
+                return this.message_received(message, false);
+            })).then(() => persistedChat);
+        }));
+    }
+    async message_received(message, live = true) {
+        // skip protocol messages (internal WhatsApp sync, not user messages)
+        if (message.message?.protocolMessage) {
+            return;
+        }
+        // skip MASK_LINKED_DEVICES placeholder — internal linked-device notification, not a user message
+        if (message.message?.placeholderMessage?.type === baileys_1.proto.Message.PlaceholderMessage.PlaceholderType.MASK_LINKED_DEVICES) {
+            return;
+        }
+        // find the chat for this message.
+        let chat = await this.store.chats().get(message.key?.remoteJid);
+        let id = message.key?.id;
+        let timestamp = message.messageTimestamp ? Number(message.messageTimestamp) : 0;
+        // verify the chat object.
+        if (!chat) {
+            console.log("could not find chat for", JSON.stringify(message.key));
+            return;
+        }
+        // lookup sender contact
+        let sender = await this.lookupOrCreateSender(message);
+        // figure out the type of the message.
+        let messageType = message.message?.conversation ? WhatsappStore_1.MessageType.Text :
+            message.message?.imageMessage ? WhatsappStore_1.MessageType.Image :
+                message.message?.videoMessage ? WhatsappStore_1.MessageType.Video :
+                    message.message?.documentMessage ? WhatsappStore_1.MessageType.Document :
+                        message.message?.templateMessage ? WhatsappStore_1.MessageType.Template :
+                            message.message?.interactiveMessage ? WhatsappStore_1.MessageType.Interactive :
+                                message.message?.extendedTextMessage ? WhatsappStore_1.MessageType.ExtendedText :
+                                    message.message?.albumMessage ? WhatsappStore_1.MessageType.Album :
+                                        message.message?.contactMessage ? WhatsappStore_1.MessageType.Contact :
+                                            message.message?.locationMessage ? WhatsappStore_1.MessageType.Location :
+                                                message.message?.liveLocationMessage ? WhatsappStore_1.MessageType.LiveLocation :
+                                                    message.messageStubType ? WhatsappStore_1.MessageType.Stub :
+                                                        WhatsappStore_1.MessageType.Unknown;
+        if (messageType === WhatsappStore_1.MessageType.Unknown) {
+            if (baileys_1.proto.WebMessageInfo.StubType.BIZ_PRIVACY_MODE_TO_FB === message.messageStubType) {
+                return;
+            }
+        }
+        let messageContents;
+        let subscriberPayload; // for image/video, includes binary data not stored in db
+        // handle a text message.
+        if (messageType === WhatsappStore_1.MessageType.Text) {
+            messageContents = { text: message.message?.conversation };
+        }
+        // handle an image message.
+        if (messageType === WhatsappStore_1.MessageType.Image) {
+            let chatId = message.key?.remoteJid;
+            let albumId = undefined;
+            // check for pending album
+            let pendingAlbum = this.pendingAlbums.get(chatId);
+            if (pendingAlbum) {
+                albumId = pendingAlbum.albumMessageId;
+                pendingAlbum.receivedImages++;
+                pendingAlbum.mediaIds.push(id);
+                // check if album is complete
+                if (pendingAlbum.receivedImages >= pendingAlbum.expectedImages &&
+                    pendingAlbum.receivedVideos >= pendingAlbum.expectedVideos) {
+                    console.log(`Album complete: ${albumId} with ${pendingAlbum.mediaIds.length} media items`);
+                    this.pendingAlbums.delete(chatId);
+                }
+            }
+            // extract metadata from image message
+            const imageMsg = message.message?.imageMessage;
+            messageContents = {
+                mimetype: imageMsg.mimetype,
+                width: imageMsg.width,
+                height: imageMsg.height,
+                fileLength: imageMsg.fileLength ? Number(imageMsg.fileLength) : undefined,
+                caption: imageMsg.caption,
+                albumId: albumId,
+            };
+            // only download media for live messages — historical URLs expire quickly and will 403
+            if (live) {
+                try {
+                    const imageData = await (0, baileys_1.downloadMediaMessage)(message, 'buffer', {}, { logger: this.logger, reuploadRequest: this.socket.updateMediaMessage });
+                    subscriberPayload = { ...messageContents, data: imageData };
+                }
+                catch (error) {
+                    console.log("Failed to download image:", error);
+                    subscriberPayload = { ...messageContents, data: null };
+                }
+            }
+        }
+        // handle a video message.
+        if (messageType === WhatsappStore_1.MessageType.Video) {
+            let chatId = message.key?.remoteJid;
+            let albumId = undefined;
+            // check for pending album
+            let pendingAlbum = this.pendingAlbums.get(chatId);
+            if (pendingAlbum) {
+                albumId = pendingAlbum.albumMessageId;
+                pendingAlbum.receivedVideos++;
+                pendingAlbum.mediaIds.push(id);
+                // check if album is complete
+                if (pendingAlbum.receivedImages >= pendingAlbum.expectedImages &&
+                    pendingAlbum.receivedVideos >= pendingAlbum.expectedVideos) {
+                    console.log(`Album complete: ${albumId} with ${pendingAlbum.mediaIds.length} media items`);
+                    this.pendingAlbums.delete(chatId);
+                }
+            }
+            // extract metadata from video message
+            const videoMsg = message.message?.videoMessage;
+            messageContents = {
+                mimetype: videoMsg.mimetype,
+                width: videoMsg.width,
+                height: videoMsg.height,
+                fileLength: videoMsg.fileLength ? Number(videoMsg.fileLength) : undefined,
+                seconds: videoMsg.seconds,
+                caption: videoMsg.caption,
+                albumId: albumId,
+            };
+            // only download media for live messages — historical URLs expire quickly and will 403
+            if (live) {
+                try {
+                    const videoData = await (0, baileys_1.downloadMediaMessage)(message, 'buffer', {}, { logger: this.logger, reuploadRequest: this.socket.updateMediaMessage });
+                    subscriberPayload = { ...messageContents, data: videoData };
+                }
+                catch (error) {
+                    console.log("Failed to download video:", error);
+                    subscriberPayload = { ...messageContents, data: null };
+                }
+            }
+        }
+        if (messageType === WhatsappStore_1.MessageType.Document) {
+            const docMsg = message.message?.documentMessage;
+            messageContents = {
+                filename: docMsg.fileName,
+                mimetype: docMsg.mimetype,
+                fileLength: docMsg.fileLength ? Number(docMsg.fileLength) : undefined,
+                pageCount: docMsg.pageCount,
+                caption: docMsg.caption,
+            };
+        }
+        if (messageType === WhatsappStore_1.MessageType.Template) {
+            // the sensible way to handle this for now is to change it to a Text Mesasge.
+            messageContents = {
+                contentText: message.message.templateMessage.hydratedTemplate.hydratedContentText,
+                footerText: message.message.templateMessage.hydratedTemplate.hydratedFooterText,
+                commands: []
+            };
+            if (message.message.templateMessage.hydratedTemplate.hydratedButtons) {
+                for (let button of message.message.templateMessage.hydratedTemplate.hydratedButtons) {
+                    if (button.urlButton) {
+                        messageContents.commands.push({ text: button.urlButton.displayText, url: button.urlButton.url });
+                        continue;
+                    }
+                    if (button.quickReplyButton) {
+                        messageContents.commands.push({ text: button.quickReplyButton.displayText, id: button.quickReplyButton.id });
+                        continue;
+                    }
+                    console.log("UNHANDLED TEMPLATE BUTTON", message.message.templateMessage.hydratedTemplate.hydratedButtons);
+                }
+            }
+        }
+        if (messageType === WhatsappStore_1.MessageType.Interactive) {
+            let msg = message.message.interactiveMessage;
+            messageContents = {
+                headerText: msg.header,
+                contentText: msg.body,
+                footerText: msg.footer,
+                commands: [],
+            };
+            if (msg.nativeFlowMessage?.buttons) {
+                for (let button of msg.nativeFlowMessage.buttons) {
+                    if (button.buttonParamsJson) {
+                        let buttonMarkup = JSON.parse(button.buttonParamsJson);
+                        messageContents.commands.push({ text: buttonMarkup.display_text, url: buttonMarkup.url });
+                        continue;
+                    }
+                    console.log("UNHANDLED nativeFlowMessage BUTTON", msg);
+                }
+            }
+            if (msg.carouselMessage || msg.collectionMessage || msg.shopStorefrontMessage || msg.contextInfo || msg.urlTrackingMap) {
+                console.log("UNHANDLED interactiveMessage Component", msg);
+            }
+        }
+        if (messageType === WhatsappStore_1.MessageType.ExtendedText) {
+            messageContents = { text: message.message?.extendedTextMessage?.text };
+        }
+        // handle an album message.
+        if (messageType === WhatsappStore_1.MessageType.Album) {
+            let chatId = message.key?.remoteJid;
+            // if there's already a pending album for this chat, finalize it
+            if (this.pendingAlbums.has(chatId)) {
+                console.log(`Album interrupted: finalizing previous album for chat ${chatId}`);
+                this.pendingAlbums.delete(chatId);
+            }
+            // create new pending album
+            let albumMessage = message.message?.albumMessage;
+            this.pendingAlbums.set(chatId, {
+                chatId: chatId,
+                albumMessageId: id,
+                expectedImages: albumMessage.expectedImageCount ?? 0,
+                expectedVideos: albumMessage.expectedVideoCount ?? 0,
+                receivedImages: 0,
+                receivedVideos: 0,
+                createdAt: Date.now(),
+                mediaIds: []
+            });
+            messageContents = {
+                expectedImages: albumMessage.expectedImageCount,
+                expectedVideos: albumMessage.expectedVideoCount
+            };
+        }
+        if (messageType === WhatsappStore_1.MessageType.Contact) {
+            messageContents = {
+                name: message.message?.contactMessage?.displayName,
+                vcard: message.message?.contactMessage?.vcard,
+            };
+        }
+        if (messageType === WhatsappStore_1.MessageType.Location) {
+            const loc = message.message?.locationMessage;
+            messageContents = {
+                latitude: loc.degreesLatitude,
+                longitude: loc.degreesLongitude,
+            };
+        }
+        if (messageType === WhatsappStore_1.MessageType.LiveLocation) {
+            const loc = message.message?.liveLocationMessage;
+            messageContents = {
+                latitude: loc.degreesLatitude,
+                longitude: loc.degreesLongitude,
+                sequenceNumber: loc.sequenceNumber != null ? String(loc.sequenceNumber) : undefined,
+            };
+        }
+        if (messageType === WhatsappStore_1.MessageType.Stub) {
+            // stub message. doesnt do much by the looks of it.
+        }
+        if (messageType === WhatsappStore_1.MessageType.Unknown) {
+            console.log("unkown new message: ", JSON.stringify(message, null, 2));
+        }
+        // persist the message.
+        await this.store.messages().create(chat, id, timestamp, messageType, JSON.stringify(messageContents, null, 2));
+        // send the message to the subscribers.
+        let whatsappmessage = {
+            timestamp: timestamp,
+            messageId: id,
+            chat: {
+                id: chat.id,
+                name: chat.name,
+            },
+            sender: {
+                id: sender?.id ?? "unknown",
+                name: sender?.getName() ?? "unknown",
+                me: !!message.key?.fromMe
+            },
+            type: messageType,
+            payload: subscriberPayload ?? messageContents,
+        };
+        Object.values(this.messageSubscribers).forEach(subscriber => subscriber(whatsappmessage));
+    }
+    /**
+     * Lookup or create the sender contact from a message.
+     * For received messages, uses lid-based lookup first (if addressingMode is "lid"),
+     * then falls back to id-based lookup.
+     * Creates a new contact if not found, and back-populates the name from pushName if missing.
+     */
+    async lookupOrCreateSender(message) {
+        const key = message.key;
+        if (!key)
+            return null;
+        const participant = key.participant; // lid format: "<lid>@lid"
+        const participantAlt = key.participantAlt; // id format: "<phone>@s.whatsapp.net"
+        const addressingMode = key.addressingMode;
+        const pushName = message.pushName;
+        let contact = null;
+        // Try lid-based lookup first if addressingMode is "lid"
+        if (addressingMode === "lid" && participant) {
+            contact = await this.store.contacts().getByLid(participant);
+        }
+        // Fall back to id-based lookup using participantAlt
+        if (!contact && participantAlt) {
+            contact = await this.store.contacts().get(participantAlt);
+        }
+        // If still not found and we have participantAlt, create a new contact
+        if (!contact && participantAlt) {
+            contact = await this.store.contacts().create(participantAlt);
+            // Set the lid if we have it
+            if (participant && addressingMode === "lid") {
+                contact.lid = participant;
+            }
+        }
+        // Back-populate name from pushName if the contact exists but has no name
+        if (contact && pushName && !contact.name) {
+            contact.name = pushName;
+        }
+        // Save any updates
+        if (contact) {
+            await this.store.contacts().save(contact);
+        }
+        return contact;
+    }
+    async doNothing(message) {
+        // do nothing.
+    }
+}
+exports.WhatsappClient = WhatsappClient;
+class GroupService {
+    constructor(socket, store, state) {
+        this.socket = socket;
+        this.store = store;
+        this.state = state;
+    }
+    async getAll() {
+        // creds.me is only populated after authentication — guard against undefined for new accounts.
+        const myJid = this.state.creds.me?.id.replace(/:\d+(?=@)/, "") ?? "";
+        return this.store.chats().getGroups()
+            .then(groups => groups
+            .map(groups => ({
+            id: groups.id,
+            subject: groups.name,
+            participants: (!groups.participants) ? [] : groups.participants.map(p => ({
+                id: p.contact.id,
+                name: p.contact.name ?? "",
+                role: p.role,
+                label: p.label,
+                isMe: myJid !== "" && p.contact.id === myJid,
+            }))
+        })));
+    }
+    async createGroup(subject) {
+        let group = await this.socket.groupCreate(subject, []);
+        return {
+            id: group.id,
+            subject: group.subject,
+            participants: group.participants.map(p => ({
+                id: p.id,
+                role: WAClientHelper.parseRole(p.admin)
+            }))
+        };
+    }
+    /**
+     * Add a user as a participant to a group.
+     * @param userId the Id of the user. should be in the phonenumber format: <phone>@s.whatsapp.net
+     * @param groupId the groupId. it is expectedd that the group is known and can be added to at this point.
+     * @param role the role that the user should be assigned.
+     * @returns nothing.
+     */
+    async addUserToGroup(userId, groupId, role) {
+        let group = this.store.chats().get(groupId);
+        if (!group) {
+            console.log(`addUserToGroup: group '${groupId}' not found`);
+            return;
+        }
+        await this.socket.groupParticipantsUpdate(groupId, [userId], 'add');
+        // promote the user if need be.
+        if (role !== WhatsappStore_1.Role.Member) {
+            await this.socket.groupParticipantsUpdate(groupId, [userId], "promote");
+        }
+        return;
+    }
+    /**
+     * Update a user's role in a group.
+     * @param userId the Id of the user. should be in the phonenumber format: <phone>@s.whatsapp.net
+     * @param groupId the groupId.
+     * @param role the new role for the user.
+     */
+    async updateUserRole(userId, groupId, role) {
+        if (role === WhatsappStore_1.Role.Member) {
+            await this.socket.groupParticipantsUpdate(groupId, [userId], 'demote');
+        }
+        else {
+            await this.socket.groupParticipantsUpdate(groupId, [userId], 'promote');
+        }
+    }
+    /**
+     * Remove a user from a group.
+     * @param userId the Id of the user. should be in the phonenumber format: <phone>@s.whatsapp.net
+     * @param groupId the groupId. it is expectedd that the group is known and can be added to at this point.
+     * @returns nothing
+     */
+    async removeUserFromGroup(userId, groupId) {
+        let group = this.store.chats().get(groupId);
+        if (!group) {
+            console.log(`addUserToGroup: group '${groupId}' not found`);
+            return;
+        }
+        await this.socket.groupParticipantsUpdate(groupId, [userId], 'remove');
+        return;
+    }
+}
+class WAClientHelper {
+    static parseRole(value) {
+        if (!value) {
+            return WhatsappStore_1.Role.Member;
+        }
+        if (value.toLocaleLowerCase() === "admin") {
+            return WhatsappStore_1.Role.Admin;
+        }
+        return WhatsappStore_1.Role.SuperAdmin;
+    }
+}
+class GroupClient {
+    constructor(client, id) {
+        this._client = client;
+        this._id = id;
+    }
+    id() {
+        return this._id;
+    }
+    subscribe(subscription) {
+        this._client.subscribe(subscription, { groupId: this.id() });
+    }
+    unsubscribe(subscription) {
+        this._client.unsubscribe(subscription);
+    }
+    sendMessage(message) {
+        this._client.sendMessage(this.id(), message);
+    }
+}
+exports.GroupClient = GroupClient;
+var ChatType;
+(function (ChatType) {
+    ChatType["Group"] = "Group";
+    ChatType["Conversation"] = "Conversation";
+})(ChatType || (exports.ChatType = ChatType = {}));