@theotherwillembotha/node-red-whatsapp 0.0.55 → 0.3.0

package/build/whatsapp/service/WhatsappClient.js

@@ -50,6 +50,7 @@ class WhatsappClient {
         this.onQRCodeListeners = [];
         this.onConnectionSuccessListeners = [];
         this.messageSubscribers = {};
+        this.subscriberKeys = new Map();
         this.groupClients = {};
         this.pendingAlbums = new Map();
         this.config = config;
@@ -58,11 +59,13 @@ class WhatsappClient {
         return this.config;
     }
     details() {
-        //@ts-ignore
-        let userID = this.state.creds.me.id.replace(/:\d+(?=@)/, "");
+        if (!this.state?.creds?.me)
+            return null;
+        const userID = this.state.creds.me.id.replace(/:\d+(?=@)/, "");
         return {
-            userID: userID,
-            msisdn: userID.substring(0, userID.indexOf("@"))
+            userID,
+            msisdn: userID.substring(0, userID.indexOf("@")),
+            name: this.state.creds.me.name ?? undefined,
         };
     }
     onQRCode(listener) {
@@ -85,20 +88,21 @@ class WhatsappClient {
     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);
             }
         };
+        this.subscriberKeys.set(listener, subscriberID);
         return subscriberID;
     }
     unsubscribe(subscriber) {
-        Object.entries(this.messageSubscribers)
-            .filter(([key, value]) => value === subscriber)
-            .forEach(([key, value]) => delete this.messageSubscribers[key]);
+        const id = this.subscriberKeys.get(subscriber);
+        if (id) {
+            delete this.messageSubscribers[id];
+            this.subscriberKeys.delete(subscriber);
+        }
     }
     subscribers() {
         return Object.values(this.messageSubscribers);
@@ -106,18 +110,30 @@ class WhatsappClient {
     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.video) {
+            result = await this.socket.sendMessage(chatId, {
+                video: message.video,
+                caption: message.text
+            });
+        }
+        else if (message.document) {
+            result = await this.socket.sendMessage(chatId, {
+                document: message.document,
+                fileName: message.documentName ?? 'document',
+                mimetype: message.documentMimetype ?? 'application/octet-stream',
+                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");
+            throw new Error("Message must contain text, image, or video");
         }
         return { messageId: result.key.id };
     }
@@ -336,6 +352,27 @@ class WhatsappClient {
             this.start();
         }, delayMs);
     }
+    /**
+     * Normalises a JID for outbound sending:
+     *   - @lid  → resolves to phone-number JID via the contact store
+     *   - contains "@" → assumed to be a fully-qualified JID; passed through unchanged
+     *   - otherwise → treated as a bare phone number; non-digits are stripped and
+     *                 "@s.whatsapp.net" is appended (works for arbitrary contacts too)
+     */
+    async resolveJid(jid) {
+        if (jid.endsWith("@lid")) {
+            const contact = await this.store.contacts().getByLid(jid);
+            if (contact)
+                return contact.id;
+            console.log(`resolveJid: cannot resolve LID ${jid} — sending as-is`);
+            return jid;
+        }
+        if (jid.includes("@"))
+            return jid;
+        // Bare phone number — strip formatting characters and construct JID
+        const digits = jid.replace(/\D/g, "");
+        return `${digits}@s.whatsapp.net`;
+    }
     async stop() {
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
@@ -482,8 +519,11 @@ class WhatsappClient {
                                         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;
+                                                    message.message?.eventMessage ? WhatsappStore_1.MessageType.Event :
+                                                        message.message?.encEventResponseMessage ? WhatsappStore_1.MessageType.EventResponse :
+                                                            message.message?.stickerMessage ? WhatsappStore_1.MessageType.Sticker :
+                                                                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;
@@ -583,6 +623,16 @@ class WhatsappClient {
                 pageCount: docMsg.pageCount,
                 caption: docMsg.caption,
             };
+            if (live) {
+                try {
+                    const documentData = await (0, baileys_1.downloadMediaMessage)(message, 'buffer', {}, { logger: this.logger, reuploadRequest: this.socket.updateMediaMessage });
+                    subscriberPayload = { ...messageContents, data: documentData };
+                }
+                catch (error) {
+                    console.log("Failed to download document:", error);
+                    subscriberPayload = { ...messageContents, data: null };
+                }
+            }
         }
         if (messageType === WhatsappStore_1.MessageType.Template) {
             // the sensible way to handle this for now is to change it to a Text Mesasge.
@@ -676,6 +726,82 @@ class WhatsappClient {
                 sequenceNumber: loc.sequenceNumber != null ? String(loc.sequenceNumber) : undefined,
             };
         }
+        if (messageType === WhatsappStore_1.MessageType.Event) {
+            const evt = message.message?.eventMessage;
+            const secret = message.message?.messageContextInfo?.messageSecret;
+            messageContents = {
+                name: evt.name,
+                description: evt.description,
+                startTime: evt.startTime ? Number(evt.startTime) : undefined,
+                isCanceled: evt.isCanceled,
+                hasReminder: evt.hasReminder,
+                reminderOffsetSec: evt.reminderOffsetSec ? Number(evt.reminderOffsetSec) : undefined,
+                extraGuestsAllowed: evt.extraGuestsAllowed,
+                isScheduleCall: evt.isScheduleCall,
+                messageSecret: secret ? Buffer.from(secret).toString('base64') : undefined,
+            };
+        }
+        if (messageType === WhatsappStore_1.MessageType.EventResponse) {
+            const encResp = message.message?.encEventResponseMessage;
+            const creationKey = encResp.eventCreationMessageKey;
+            const originalMessage = await this.store.messages().get(creationKey.id);
+            const originalPayload = originalMessage ? JSON.parse(originalMessage.payload) : null;
+            const messageSecretB64 = originalPayload?.messageSecret;
+            if (!messageSecretB64) {
+                console.log("encEventResponseMessage: missing messageSecret for event", creationKey.id);
+                messageContents = { eventMessageId: creationKey.id, response: "unknown" };
+            }
+            else {
+                try {
+                    // WhatsApp LID-addressed clients use raw LIDs (not resolved phone numbers) in key derivation.
+                    const eventCreatorJid = creationKey.participant || creationKey.remoteJid || "";
+                    const responderJid = message.key?.participant || message.key?.remoteJid || "";
+                    const responseMsg = (0, baileys_1.decryptEventResponse)({ encPayload: encResp.encPayload, encIv: encResp.encIv }, {
+                        eventEncKey: Buffer.from(messageSecretB64, 'base64'),
+                        eventCreatorJid,
+                        eventMsgId: creationKey.id,
+                        responderJid,
+                    });
+                    const responseType = responseMsg.response;
+                    const responseStr = responseType === baileys_1.proto.Message.EventResponseMessage.EventResponseType.GOING ? "going" :
+                        responseType === baileys_1.proto.Message.EventResponseMessage.EventResponseType.NOT_GOING ? "not_going" :
+                            responseType === baileys_1.proto.Message.EventResponseMessage.EventResponseType.MAYBE ? "maybe" :
+                                "unknown";
+                    messageContents = {
+                        eventMessageId: creationKey.id,
+                        response: responseStr,
+                        timestampMs: responseMsg.timestampMs ? Number(responseMsg.timestampMs) : undefined,
+                        extraGuestCount: responseMsg.extraGuestCount ?? undefined,
+                    };
+                }
+                catch (error) {
+                    console.log("encEventResponseMessage: decryption failed", error);
+                    messageContents = { eventMessageId: creationKey.id, response: "unknown" };
+                }
+            }
+        }
+        if (messageType === WhatsappStore_1.MessageType.Sticker) {
+            const stickerMsg = message.message?.stickerMessage;
+            messageContents = {
+                mimetype: stickerMsg.mimetype,
+                width: stickerMsg.width,
+                height: stickerMsg.height,
+                fileLength: stickerMsg.fileLength ? Number(stickerMsg.fileLength) : undefined,
+                isAnimated: stickerMsg.isAnimated,
+                isLottie: stickerMsg.isLottie,
+                isAiSticker: stickerMsg.isAiSticker,
+            };
+            if (live) {
+                try {
+                    const stickerData = await (0, baileys_1.downloadMediaMessage)(message, 'buffer', {}, { logger: this.logger, reuploadRequest: this.socket.updateMediaMessage });
+                    subscriberPayload = { ...messageContents, data: stickerData };
+                }
+                catch (error) {
+                    console.log("Failed to download sticker:", error);
+                    subscriberPayload = { ...messageContents, data: null };
+                }
+            }
+        }
         if (messageType === WhatsappStore_1.MessageType.Stub) {
             // stub message. doesnt do much by the looks of it.
         }

package/build/whatsapp/service/WhatsappService.js

@@ -1,15 +1,34 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var WhatsappService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsappService = void 0;
 const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
 const WhatsappClient_1 = require("./WhatsappClient");
 const fs_1 = __importDefault(require("fs"));
 const qrcode_1 = __importDefault(require("qrcode"));
-class WhatsappService extends node_red_plugincore_1.BaseService {
-    static { this.clients = {}; }
+let WhatsappService = class WhatsappService extends node_red_plugincore_1.BaseService {
+    static { WhatsappService_1 = this; }
+    // clients is stored in global so that Nodes.js and Plugins.js (which are separate esbuild
+    // bundles containing separate copies of this class) share the same runtime map.
+    static { this._CLIENTS_KEY = '__wa_service_clients__'; }
+    static clients() {
+        if (!global[WhatsappService_1._CLIENTS_KEY]) {
+            global[WhatsappService_1._CLIENTS_KEY] = {};
+        }
+        return global[WhatsappService_1._CLIENTS_KEY];
+    }
     constructor() {
         super("WhatsappService");
         this.connections = [];
@@ -20,6 +39,8 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         console.log("STARTING: WhatsappService");
         // whatsapp client commands.
         let writePermission = red.auth.needsPermission("inject.write");
+        let readPermission = red.auth.needsPermission("nodes.read");
+        red.httpAdmin.get("/whatsapp/accounts", readPermission, (request, response) => this.getAccounts(request, response));
         red.httpAdmin.post("/whatsapp/linkaccount", writePermission, (request, response) => this.linkAccount(request, response));
         red.httpAdmin.post("/whatsapp/unlinkaccount", writePermission, (request, response) => this.unlinkaccount(request, response));
         red.httpAdmin.post("/whatsapp/getgroups", writePermission, (request, response) => this.getGroups(request, response));
@@ -28,9 +49,6 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         red.httpAdmin.post("/whatsapp/groupupdateuser", writePermission, (request, response) => this.groupUpdateUser(request, response));
         red.httpAdmin.post("/whatsapp/groupremoveuser", writePermission, (request, response) => this.groupRemoveUser(request, response));
         try {
-            // TODO: change the way we determine a suitable sorage location for the whatsapp data.
-            // if the /data folder exists, then this is probably a custom image and we can safely store the information in /data
-            // if it doesnt exist, then just save it to the current working folder.
             if (fs_1.default.existsSync("/data")) {
                 console.log("Using /data as storage location");
                 this.configDir = "/data/whatsapp";
@@ -39,7 +57,6 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
                 this.configDir = "whatsapp";
             }
             this.configFile = this.configDir + "/connections.json";
-            // check if the directory exists.
             if (!fs_1.default.existsSync(this.configDir)) {
                 fs_1.default.mkdirSync(this.configDir);
             }
@@ -56,7 +73,9 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
                     localConnectionId: connection.key,
                     fileStorageRoot: this.configDir
                 });
-                WhatsappService.clients[connection.key] = client;
+                WhatsappService_1.clients()[connection.key] = client;
+                // save account details (name, phone) to connections.json after each reconnect
+                client.onConnectionSuccess(() => this.saveConnectionDetails(connection.key));
                 return client.start();
             }));
         }
@@ -64,11 +83,47 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
             console.log(error);
         }
     }
+    saveConnectionDetails(key) {
+        try {
+            const client = WhatsappService_1.clients()[key];
+            if (!client)
+                return;
+            const details = client.details();
+            if (!details)
+                return;
+            const conn = this.connections.find(c => c.key === key);
+            if (conn) {
+                conn.name = details.name;
+                conn.phoneNumber = details.msisdn;
+                fs_1.default.writeFileSync(this.configFile, JSON.stringify(this.connections, null, 2), { flag: "w+" });
+            }
+        }
+        catch (e) {
+            console.log("saveConnectionDetails failed", e);
+        }
+    }
+    getAccounts(request, response) {
+        // collect localConnectionIds claimed by WhatsappAccountConfigNodes in the current flow
+        const claimedKeys = new Set();
+        this.red.nodes.eachNode((nodeConfig) => {
+            if (nodeConfig.type === 'WhatsappAccountConfigNode' && nodeConfig.localConnectionId) {
+                claimedKeys.add(nodeConfig.localConnectionId);
+            }
+        });
+        const accounts = this.connections.map(connection => ({
+            key: connection.key,
+            name: connection.name,
+            phoneNumber: connection.phoneNumber,
+            connected: !!WhatsappService_1.clients()[connection.key],
+            claimed: claimedKeys.has(connection.key),
+        }));
+        response.send(accounts);
+    }
     deinit(red) {
         console.log("STOPPING: WhatsappService");
     }
     static getClient(localConnectionId) {
-        return this.clients[localConnectionId];
+        return WhatsappService_1.clients()[localConnectionId];
     }
     linkAccount(request, response) {
         let linkRequest = request.body;
@@ -116,15 +171,16 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
             // make sure we havent got this connection already.
             let knownConnection = this.connections.find(connection => connection.key === linkRequest.localConnectionId);
             if (!knownConnection) {
-                this.connections.push({
-                    key: linkRequest.localConnectionId
-                });
+                this.connections.push({ key: linkRequest.localConnectionId });
+                // ensure the new entry exists before saveConnectionDetails tries to update it
                 fs_1.default.writeFileSync(this.configFile, JSON.stringify(this.connections, null, 2), { flag: "w+" });
             }
+            // save account details (name, phone) to disk
+            this.saveConnectionDetails(linkRequest.localConnectionId);
             // stop the timeout timer, and move client from tempclients to clients.
             clearTimeout(timeoutTimer);
             delete this.tempClients[linkRequest.localConnectionId];
-            WhatsappService.clients[linkRequest.localConnectionId] = client;
+            WhatsappService_1.clients()[linkRequest.localConnectionId] = client;
             // send a notification to the frontend.
             red.events.emit("runtime-event", {
                 id: "whatsapp/" + linkRequest.localConnectionId,
@@ -140,10 +196,10 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
     unlinkaccount(request, response) {
         let unlinkAccountRequest = request.body;
         // get an instance of the client and stop it.
-        let client = WhatsappService.clients[unlinkAccountRequest.localConnectionId];
+        let client = WhatsappService_1.clients()[unlinkAccountRequest.localConnectionId];
         let deleteAccountData = () => {
             // after stopping the client, remove it from the clients list, update the connections file, and remove its storage.
-            delete WhatsappService.clients[unlinkAccountRequest.localConnectionId];
+            delete WhatsappService_1.clients()[unlinkAccountRequest.localConnectionId];
             this.connections = this.connections.filter(connection => connection.key !== unlinkAccountRequest.localConnectionId);
             fs_1.default.writeFileSync(this.configFile, JSON.stringify(this.connections, null, 2), { flag: "w+" });
             fs_1.default.rmSync(this.configDir + "/" + unlinkAccountRequest.localConnectionId, { recursive: true });
@@ -158,7 +214,7 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         }
     }
     async getGroups(request, response) {
-        let client = WhatsappService.clients[request.body.localConnectionId];
+        let client = WhatsappService_1.clients()[request.body.localConnectionId];
         if (client) {
             response.send(await client.groups().getAll());
         }
@@ -167,7 +223,7 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         }
     }
     async createGroup(request, response) {
-        let client = WhatsappService.clients[request.body.localConnectionId];
+        let client = WhatsappService_1.clients()[request.body.localConnectionId];
         if (client) {
             response.send(await client.groups().createGroup(request.body.groupName));
         }
@@ -176,7 +232,7 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         }
     }
     async groupAddUser(request, response) {
-        let client = WhatsappService.clients[request.body.localConnectionId];
+        let client = WhatsappService_1.clients()[request.body.localConnectionId];
         if (client) {
             await client.groups().addUserToGroup(request.body.userId, request.body.groupId, request.body.role);
             response.send({ status: "ok" });
@@ -186,7 +242,7 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         }
     }
     async groupUpdateUser(request, response) {
-        let client = WhatsappService.clients[request.body.localConnectionId];
+        let client = WhatsappService_1.clients()[request.body.localConnectionId];
         if (client) {
             await client.groups().updateUserRole(request.body.userId, request.body.groupId, request.body.role);
             response.send({ status: "ok" });
@@ -196,7 +252,7 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
         }
     }
     async groupRemoveUser(request, response) {
-        let client = WhatsappService.clients[request.body.localConnectionId];
+        let client = WhatsappService_1.clients()[request.body.localConnectionId];
         if (client) {
             await client.groups().removeUserFromGroup(request.body.userId, request.body.groupId);
             response.send({ status: "ok" });
@@ -205,8 +261,14 @@ class WhatsappService extends node_red_plugincore_1.BaseService {
             response.status(500).send({ message: "Client not linked" });
         }
     }
-    static getServiceDescriptor() {
-        return new node_red_plugincore_1.ServiceDescriptor("@theotherwillembotha/whatsappservice", "WhatsappService", "integration-plugin", "./whatsapp/service/WhatsappService", WhatsappService);
-    }
-}
+};
 exports.WhatsappService = WhatsappService;
+exports.WhatsappService = WhatsappService = WhatsappService_1 = __decorate([
+    (0, node_red_plugincore_1.ServiceDescription)({
+        id: "@theotherwillembotha/whatsappservice",
+        name: "WhatsappService",
+        type: "integration-plugin",
+        sourceFile: "./whatsapp/service/WhatsappService",
+    }),
+    __metadata("design:paramtypes", [])
+], WhatsappService);

package/build/whatsapp/service/WhatsappStore.js

@@ -233,20 +233,20 @@ class ChatDAO extends DAO {
     async getWithParticipants(id) {
         return this.em().findOne(Chat, {
             where: { id },
-            relations: ['participants', 'participants.contact']
+            relations: { participants: { contact: true } }
         });
     }
     async getGroups() {
         return this.em().find(Chat, {
             where: { type: WhatsappClient_1.ChatType.Group },
-            relations: ['participants', 'participants.contact']
+            relations: { participants: { contact: true } }
         });
     }
     async save(chat) {
         return this.em().save(chat);
     }
     async delete(chatId) {
-        const chat = await this.em().findOne(Chat, { where: { id: chatId }, relations: ['participants'] });
+        const chat = await this.em().findOne(Chat, { where: { id: chatId }, relations: { participants: true } });
         if (chat) {
             await this.em().remove(chat);
         }
@@ -254,7 +254,7 @@ class ChatDAO extends DAO {
     async removeParticipants(chatId, contactIds) {
         const chat = await this.em().findOne(Chat, {
             where: { id: chatId },
-            relations: ['participants', 'participants.contact']
+            relations: { participants: { contact: true } }
         });
         if (!chat)
             return;
@@ -264,7 +264,7 @@ class ChatDAO extends DAO {
     async updateParticipantRole(chatId, contactId, role) {
         const chat = await this.em().findOne(Chat, {
             where: { id: chatId },
-            relations: ['participants', 'participants.contact']
+            relations: { participants: { contact: true } }
         });
         if (!chat)
             return;
@@ -277,7 +277,7 @@ class ChatDAO extends DAO {
     async updateParticipantLabel(chatId, contactId, label) {
         const chat = await this.em().findOne(Chat, {
             where: { id: chatId },
-            relations: ['participants', 'participants.contact']
+            relations: { participants: { contact: true } }
         });
         if (!chat)
             return;
@@ -367,7 +367,7 @@ class MessageDAO extends DAO {
     }
     async create(chat, id, timestamp, type, payload) {
         // first check if the client exists.
-        let message = await this.em().findOneBy(Message, { id: id, chat: chat });
+        let message = await this.em().findOneBy(Message, { id: id, chat: { id: chat.id } });
         if (message) {
             let modified = true;
             if (message.timestamp !== timestamp) {
@@ -405,4 +405,7 @@ var MessageType;
     MessageType["Interactive"] = "Interactive";
     MessageType["Location"] = "Location";
     MessageType["LiveLocation"] = "LiveLocation";
+    MessageType["Event"] = "Event";
+    MessageType["EventResponse"] = "EventResponse";
+    MessageType["Sticker"] = "Sticker";
 })(MessageType || (exports.MessageType = MessageType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theotherwillembotha/node-red-whatsapp",
-  "version": "0.0.55",
+  "version": "0.3.0",
   "description": "Node-RED nodes for WhatsApp messaging via the Baileys library.",
   "author": "Willem Botha (@theotherwillembotha)",
   "license": "ISC",
@@ -15,10 +15,11 @@
   "exports": "./build/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "npm run clean && tsc && npm run generate-nodes && npm run copy-files",
+    "build": "npm run clean && tsc && npm run generate-nodes && npm run bundle && npm run copy-files",
     "clean": "rm -rf ./build",
     "typeorm": "typeorm-ts-node-commonjs",
     "generate-nodes": "node build/GenerateNodes.js",
+    "bundle": "node esbuild.js",
     "copy-files": "cp -r ./icons ./build/"
   },
   "files": [
@@ -43,20 +44,21 @@
     "nodered": ">=4.0.0"
   },
   "dependencies": {
-    "@theotherwillembotha/node-red-plugincore": "^0.0.55",
-    "baileys": "7.0.0-rc11",
-    "handlebars": "^4.7.8",
+    "@theotherwillembotha/node-red-plugincore": "^0.3.0",
+    "baileys": "7.0.0-rc14",
+    "handlebars": "^4.7.9",
     "node-cache": "^5.1.2",
     "qrcode": "^1.5.4",
-    "sql.js": "^1.13.0",
-    "typeorm": "^0.3.28",
-    "uuid": "^13.0.0"
+    "sql.js": "^1.14.1",
+    "typeorm": "^1.0.0",
+    "uuid": "^14.0.1"
   },
   "devDependencies": {
     "@theotherwillembotha/node-red-plugincore": "../nodered_plugincore",
     "@types/node": "^22.15.16",
     "@types/node-red": "~1.3.5",
     "@types/qrcode": "^1.5.6",
+    "esbuild": "^0.25.0",
     "ts-node": "^10.9.2"
   },
   "node-red": {