@theotherwillembotha/node-red-whatsapp 0.0.55

package/build/whatsapp/service/WhatsappService.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 = {}; }
+    constructor() {
+        super("WhatsappService");
+        this.connections = [];
+        this.tempClients = {}; // temp clients are used to keep references to clients while linking accounts.
+    }
+    async init(red) {
+        this.red = red;
+        console.log("STARTING: WhatsappService");
+        // whatsapp client commands.
+        let writePermission = red.auth.needsPermission("inject.write");
+        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));
+        red.httpAdmin.post("/whatsapp/creategroup", writePermission, (request, response) => this.createGroup(request, response));
+        red.httpAdmin.post("/whatsapp/groupadduser", writePermission, (request, response) => this.groupAddUser(request, response));
+        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";
+            }
+            else {
+                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);
+            }
+            if (!fs_1.default.existsSync(this.configFile)) {
+                fs_1.default.writeFileSync(this.configFile, JSON.stringify([], null, 2), { flag: "w+" });
+            }
+            // read the connections file and start the clients.
+            this.connections = JSON.parse(fs_1.default.readFileSync(this.configFile).toString());
+            if (this.connections.length === 0) {
+                console.log("whatsapp: no connections yet");
+            }
+            await Promise.all(this.connections.map(connection => {
+                let client = new WhatsappClient_1.WhatsappClient({
+                    localConnectionId: connection.key,
+                    fileStorageRoot: this.configDir
+                });
+                WhatsappService.clients[connection.key] = client;
+                return client.start();
+            }));
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    deinit(red) {
+        console.log("STOPPING: WhatsappService");
+    }
+    static getClient(localConnectionId) {
+        return this.clients[localConnectionId];
+    }
+    linkAccount(request, response) {
+        let linkRequest = request.body;
+        console.log("Received request: ", linkRequest);
+        let red = this.red;
+        // create a whatsapp client.
+        let client = new WhatsappClient_1.WhatsappClient({
+            localConnectionId: linkRequest.localConnectionId,
+            fileStorageRoot: this.configDir
+        });
+        this.tempClients[linkRequest.localConnectionId] = client;
+        // start a timer that will only attempt to create a connection for 3min... after that it will close the connection.
+        let timeoutTimer = setTimeout(() => {
+            console.log("link account request timed out for " + linkRequest.localConnectionId);
+            client.stop().then(() => {
+                console.log("connection closed " + linkRequest.localConnectionId);
+                fs_1.default.rmSync(this.configDir + "/" + linkRequest.localConnectionId, { recursive: true });
+            });
+            delete this.tempClients[linkRequest.localConnectionId];
+            red.events.emit("runtime-event", {
+                id: "whatsapp/" + linkRequest.localConnectionId,
+                retain: false,
+                payload: {
+                    type: "account_link_timeout"
+                }
+            });
+        }, 3 * 60 * 1000);
+        client.onQRCode((qrcode) => {
+            qrcode_1.default.toString(qrcode, { type: "svg" }, function (error, svgImage) {
+                if (error) {
+                    console.log("Error", error);
+                    return;
+                }
+                red.events.emit("runtime-event", {
+                    id: "whatsapp/" + linkRequest.localConnectionId,
+                    retain: false,
+                    payload: {
+                        type: "qrcode",
+                        qrcode: svgImage
+                    }
+                });
+            });
+        });
+        client.onConnectionSuccess(() => {
+            // 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
+                });
+                fs_1.default.writeFileSync(this.configFile, JSON.stringify(this.connections, null, 2), { flag: "w+" });
+            }
+            // stop the timeout timer, and move client from tempclients to clients.
+            clearTimeout(timeoutTimer);
+            delete this.tempClients[linkRequest.localConnectionId];
+            WhatsappService.clients[linkRequest.localConnectionId] = client;
+            // send a notification to the frontend.
+            red.events.emit("runtime-event", {
+                id: "whatsapp/" + linkRequest.localConnectionId,
+                retain: false,
+                payload: {
+                    type: "account_linked"
+                }
+            });
+        });
+        client.start();
+        response.send({ status: "ok" });
+    }
+    unlinkaccount(request, response) {
+        let unlinkAccountRequest = request.body;
+        // get an instance of the client and stop it.
+        let client = WhatsappService.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];
+            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 });
+            response.send({ status: "ok" });
+        };
+        if (client) {
+            client.stop().finally(deleteAccountData);
+        }
+        else {
+            deleteAccountData();
+            response.send({ result: "ok" });
+        }
+    }
+    async getGroups(request, response) {
+        let client = WhatsappService.clients[request.body.localConnectionId];
+        if (client) {
+            response.send(await client.groups().getAll());
+        }
+        else {
+            response.status(500).send({ message: "Client not linked" });
+        }
+    }
+    async createGroup(request, response) {
+        let client = WhatsappService.clients[request.body.localConnectionId];
+        if (client) {
+            response.send(await client.groups().createGroup(request.body.groupName));
+        }
+        else {
+            response.status(500).send({ message: "Client not linked" });
+        }
+    }
+    async groupAddUser(request, response) {
+        let client = WhatsappService.clients[request.body.localConnectionId];
+        if (client) {
+            await client.groups().addUserToGroup(request.body.userId, request.body.groupId, request.body.role);
+            response.send({ status: "ok" });
+        }
+        else {
+            response.status(500).send({ message: "Client not linked" });
+        }
+    }
+    async groupUpdateUser(request, response) {
+        let client = WhatsappService.clients[request.body.localConnectionId];
+        if (client) {
+            await client.groups().updateUserRole(request.body.userId, request.body.groupId, request.body.role);
+            response.send({ status: "ok" });
+        }
+        else {
+            response.status(500).send({ message: "Client not linked" });
+        }
+    }
+    async groupRemoveUser(request, response) {
+        let client = WhatsappService.clients[request.body.localConnectionId];
+        if (client) {
+            await client.groups().removeUserFromGroup(request.body.userId, request.body.groupId);
+            response.send({ status: "ok" });
+        }
+        else {
+            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;

package/build/whatsapp/service/WhatsappStore.js

@@ -0,0 +1,408 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.Chat = exports.Contact = exports.MessageType = exports.Role = exports.WhatsappStore = void 0;
+const typeorm_1 = require("typeorm");
+const WhatsappClient_1 = require("./WhatsappClient");
+// ******************* WHATSAPP STORE ********************** //
+class WhatsappStore {
+    static async createStore(id, location) {
+        let datasource = await new typeorm_1.DataSource({
+            type: "sqljs",
+            location: `${location}/database.sqlite`,
+            synchronize: true,
+            logging: false,
+            autoSave: true,
+            entities: [Contact, Chat, Message, Participant],
+            migrations: [],
+            subscribers: [],
+        }).initialize();
+        return new WhatsappStore(id, location, datasource);
+    }
+    constructor(id, location, datasource) {
+        this._id = id;
+        this._location = location;
+        this._datasource = datasource;
+        this._contacts = new ContactDAO(this, this._datasource.manager);
+        this._chats = new ChatDAO(this, this._datasource.manager);
+        this._messages = new MessageDAO(this, this._datasource.manager);
+        // print out some db stats.
+        this.contacts().all().then(contacts => console.log("DB CONTAINS " + contacts.length + " CONTACTS"));
+        this.chats().all().then(chats => console.log("DB CONTAINS " + chats.length + " CHATS"));
+        this.messages().all().then(messages => console.log("DB CONTAINS " + messages.length + " MESSAGES"));
+    }
+    chats() {
+        return this._chats;
+    }
+    contacts() {
+        return this._contacts;
+    }
+    messages() {
+        return this._messages;
+    }
+}
+exports.WhatsappStore = WhatsappStore;
+class DAO {
+    constructor(daos, em) {
+        this._daos = daos;
+        this._em = em;
+    }
+    daos() {
+        return this._daos;
+    }
+    em() {
+        return this._em;
+    }
+}
+var ContactType;
+(function (ContactType) {
+    ContactType["USER"] = "USER";
+    ContactType["GROUP"] = "GROUP";
+})(ContactType || (ContactType = {}));
+// ******************* CONTACTS ********************** //
+let Contact = class Contact {
+    constructor(id) {
+        if (!id) {
+            return;
+        }
+        this.id = id;
+        // the ID will determine the type of the contact. if ends with "@g.us" its a group. if it ends with @s.whatsapp.net, its a user.
+        this.type =
+            id.endsWith("@s.whatsapp.net") ? ContactType.USER :
+                id.endsWith("@lid") ? ContactType.USER :
+                    ContactType.GROUP;
+        // the phone number is the bits before the @ in the id.
+        this.phoneNumber = id.substring(0, id.indexOf("@"));
+    }
+    getName() {
+        return this.name ? this.name : this.phoneNumber;
+    }
+};
+exports.Contact = Contact;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ name: "id" }),
+    __metadata("design:type", String)
+], Contact.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "type", nullable: false }),
+    __metadata("design:type", String)
+], Contact.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "phoneNumber", nullable: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "phoneNumber", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "name", nullable: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "lid", nullable: true }),
+    __metadata("design:type", String)
+], Contact.prototype, "lid", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => Participant, (participant) => participant.chat),
+    __metadata("design:type", Array)
+], Contact.prototype, "participants", void 0);
+exports.Contact = Contact = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [String])
+], Contact);
+class ContactDAO extends DAO {
+    constructor(daos, em) {
+        super(daos, em);
+    }
+    // get will always return a contact, whether it exists or not.
+    async get(id) {
+        let contact = await this.em().findOne(Contact, { where: { id: id } });
+        return contact ? contact : this.em().save(new Contact(id));
+    }
+    async all() {
+        return this.em().find(Contact);
+    }
+    async create(id) {
+        // first check if the client exists.
+        let contact = await this.em().findOne(Contact, { where: { id: id } });
+        if (contact) {
+            return contact;
+        }
+        return this.em().save(new Contact(id));
+    }
+    async save(contact) {
+        return this.em().save(contact);
+    }
+    async getByLid(lid) {
+        return this.em().findOne(Contact, { where: { lid: lid } });
+    }
+}
+var Role;
+(function (Role) {
+    Role["Admin"] = "Admin";
+    Role["SuperAdmin"] = "SuperAdmin";
+    Role["Member"] = "Member";
+})(Role || (exports.Role = Role = {}));
+// ******************* CHAT ********************** //
+let Chat = class Chat {
+    constructor(id, lid, type, owner, name, description) {
+        this.id = id;
+        this.type = type;
+        this.lid = lid;
+        this.owner = owner;
+        this.name = name;
+        this.description = description;
+    }
+    addParticipant(contact, role) {
+        if (!this.participants) {
+            this.participants = [];
+        }
+        this.participants.push(new Participant(this, contact, role));
+        return this;
+    }
+};
+exports.Chat = Chat;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ name: "id" }),
+    __metadata("design:type", String)
+], Chat.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "type", nullable: true }),
+    __metadata("design:type", String)
+], Chat.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "lid", nullable: true }),
+    __metadata("design:type", String)
+], Chat.prototype, "lid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "owner", nullable: true }),
+    __metadata("design:type", String)
+], Chat.prototype, "owner", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "name", nullable: true }),
+    __metadata("design:type", String)
+], Chat.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "description", nullable: true }),
+    __metadata("design:type", String)
+], Chat.prototype, "description", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => Participant, (participant) => participant.chat, { cascade: ["insert", "update"], onDelete: "CASCADE", orphanedRowAction: "delete" }),
+    __metadata("design:type", Array)
+], Chat.prototype, "participants", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => Message, (message) => message.chat),
+    __metadata("design:type", Array)
+], Chat.prototype, "messages", void 0);
+exports.Chat = Chat = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [String, String, String, String, String, String])
+], Chat);
+class ChatDAO extends DAO {
+    constructor(daos, em) {
+        super(daos, em);
+    }
+    async get(id) {
+        // if the id ends with @lid, then do a lookup by lid instead.
+        return (id.endsWith("@lid"))
+            ? this.em().findOne(Chat, { where: { lid: id } })
+            : this.em().findOne(Chat, { where: { id: id } });
+    }
+    async all() {
+        return this.em().find(Chat, {});
+    }
+    async create(id, lid, type, owner, name, description) {
+        let chat = await this.em().findOneBy(Chat, { id: id });
+        if (chat) {
+            // update the chat if some properties changed.
+            if (chat.name !== name) {
+                chat.name = name;
+                return this.em().save(chat);
+            }
+            else {
+                return chat;
+            }
+        }
+        return this.em().save(new Chat(id, lid, type, owner, name, description));
+    }
+    async getWithParticipants(id) {
+        return this.em().findOne(Chat, {
+            where: { id },
+            relations: ['participants', 'participants.contact']
+        });
+    }
+    async getGroups() {
+        return this.em().find(Chat, {
+            where: { type: WhatsappClient_1.ChatType.Group },
+            relations: ['participants', 'participants.contact']
+        });
+    }
+    async save(chat) {
+        return this.em().save(chat);
+    }
+    async delete(chatId) {
+        const chat = await this.em().findOne(Chat, { where: { id: chatId }, relations: ['participants'] });
+        if (chat) {
+            await this.em().remove(chat);
+        }
+    }
+    async removeParticipants(chatId, contactIds) {
+        const chat = await this.em().findOne(Chat, {
+            where: { id: chatId },
+            relations: ['participants', 'participants.contact']
+        });
+        if (!chat)
+            return;
+        chat.participants = chat.participants.filter(p => !contactIds.includes(p.contact.id));
+        await this.em().save(chat);
+    }
+    async updateParticipantRole(chatId, contactId, role) {
+        const chat = await this.em().findOne(Chat, {
+            where: { id: chatId },
+            relations: ['participants', 'participants.contact']
+        });
+        if (!chat)
+            return;
+        const participant = chat.participants.find(p => p.contact.id === contactId);
+        if (participant) {
+            participant.role = role;
+            await this.em().save(participant);
+        }
+    }
+    async updateParticipantLabel(chatId, contactId, label) {
+        const chat = await this.em().findOne(Chat, {
+            where: { id: chatId },
+            relations: ['participants', 'participants.contact']
+        });
+        if (!chat)
+            return;
+        const participant = chat.participants.find(p => p.contact.id === contactId);
+        if (participant) {
+            participant.label = label;
+            await this.em().save(participant);
+        }
+    }
+}
+// ******************* PARTICIPANT *************************** //
+let Participant = class Participant {
+    constructor(chat, contact, role) {
+        this.chat = chat;
+        this.contact = contact;
+        this.role = role;
+    }
+};
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)({ name: "id" }),
+    __metadata("design:type", String)
+], Participant.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Chat, (chat) => chat.participants),
+    __metadata("design:type", Chat)
+], Participant.prototype, "chat", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Contact, (contact) => contact.participants),
+    __metadata("design:type", Contact)
+], Participant.prototype, "contact", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], Participant.prototype, "role", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: "varchar", nullable: true }),
+    __metadata("design:type", Object)
+], Participant.prototype, "label", void 0);
+Participant = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [Chat, Contact, String])
+], Participant);
+// ******************* MESSAGES ********************** //
+let Message = class Message {
+    constructor(id, chat, timestamp, type, payload) {
+        this.id = id;
+        this.chat = chat;
+        this.timestamp = timestamp;
+        this.type = type;
+        this.payload = payload;
+    }
+};
+exports.Message = Message;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ name: "id" }),
+    __metadata("design:type", String)
+], Message.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Chat, (chat) => chat.messages),
+    __metadata("design:type", Chat)
+], Message.prototype, "chat", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], Message.prototype, "timestamp", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], Message.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], Message.prototype, "payload", void 0);
+exports.Message = Message = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [String, Chat, Number, String, String])
+], Message);
+class MessageDAO extends DAO {
+    constructor(daos, em) {
+        super(daos, em);
+    }
+    async get(id) {
+        return this.em().findOne(Message, { where: { id: id } });
+    }
+    async all() {
+        return this.em().find(Message);
+    }
+    async create(chat, id, timestamp, type, payload) {
+        // first check if the client exists.
+        let message = await this.em().findOneBy(Message, { id: id, chat: chat });
+        if (message) {
+            let modified = true;
+            if (message.timestamp !== timestamp) {
+                message.timestamp = timestamp;
+                modified = true;
+            }
+            if (message.type !== type) {
+                message.type = type;
+                modified = true;
+            }
+            if (message.payload !== payload) {
+                message.payload = payload;
+                modified = true;
+            }
+            if (modified) {
+                await this.em().save(message);
+            }
+            return message;
+        }
+        return this.em().save(new Message(id, chat, timestamp, type, payload));
+    }
+}
+var MessageType;
+(function (MessageType) {
+    MessageType["Text"] = "Text";
+    MessageType["Unknown"] = "Unknown";
+    MessageType["Image"] = "Image";
+    MessageType["Video"] = "Video";
+    MessageType["Document"] = "Document";
+    MessageType["Template"] = "Template";
+    MessageType["ExtendedText"] = "ExtendedText";
+    MessageType["Album"] = "Album";
+    MessageType["Stub"] = "Stub";
+    MessageType["Contact"] = "Contact";
+    MessageType["Interactive"] = "Interactive";
+    MessageType["Location"] = "Location";
+    MessageType["LiveLocation"] = "LiveLocation";
+})(MessageType || (exports.MessageType = MessageType = {}));

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@theotherwillembotha/node-red-whatsapp",
+  "version": "0.0.55",
+  "description": "Node-RED nodes for WhatsApp messaging via the Baileys library.",
+  "author": "Willem Botha (@theotherwillembotha)",
+  "license": "ISC",
+  "keywords": [
+    "node-red",
+    "whatsapp",
+    "baileys",
+    "messaging",
+    "chat"
+  ],
+  "main": "./build/index.js",
+  "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",
+    "clean": "rm -rf ./build",
+    "typeorm": "typeorm-ts-node-commonjs",
+    "generate-nodes": "node build/GenerateNodes.js",
+    "copy-files": "cp -r ./icons ./build/"
+  },
+  "files": [
+    "build/",
+    "icons/",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theotherwillembotha/nodered_whatsapp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/theotherwillembotha/nodered_whatsapp/issues"
+  },
+  "homepage": "https://github.com/theotherwillembotha/nodered_whatsapp#readme",
+  "engines": {
+    "node": ">=18",
+    "nodered": ">=4.0.0"
+  },
+  "dependencies": {
+    "@theotherwillembotha/node-red-plugincore": "^0.0.55",
+    "baileys": "7.0.0-rc11",
+    "handlebars": "^4.7.8",
+    "node-cache": "^5.1.2",
+    "qrcode": "^1.5.4",
+    "sql.js": "^1.13.0",
+    "typeorm": "^0.3.28",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@theotherwillembotha/node-red-plugincore": "../nodered_plugincore",
+    "@types/node": "^22.15.16",
+    "@types/node-red": "~1.3.5",
+    "@types/qrcode": "^1.5.6",
+    "ts-node": "^10.9.2"
+  },
+  "node-red": {
+    "version": ">=4.0.0",
+    "nodes": {
+      "whatsapp": "./build/Nodes.js"
+    },
+    "plugins": {
+      "whatsapp": "./build/Plugins.js"
+    }
+  }
+}