strapi-plugin-magic-mail 2.2.5 → 2.3.0

package/dist/server/index.mjs

@@ -4,6 +4,8 @@ import require$$1$1 from "os";
 import require$$0$3 from "mustache";
 import require$$1$2 from "html-to-text";
 import require$$2$2 from "decode-html";
+import require$$0$4 from "path";
+import require$$1$3 from "fs";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x2) {
   return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
@@ -257,7 +259,7 @@ const collectionName$5 = "magic_mail_routing_rules";
 const info$5 = { "singularName": "routing-rule", "pluralName": "routing-rules", "displayName": "Email Routing Rule", "description": "Rules for routing emails to specific accounts" };
 const options$5 = { "draftAndPublish": false };
 const pluginOptions$5 = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
-const attributes$5 = { "name": { "type": "string", "required": true, "unique": true }, "description": { "type": "text" }, "isActive": { "type": "boolean", "default": true, "required": true }, "priority": { "type": "integer", "default": 1, "min": 1 }, "matchType": { "type": "enumeration", "enum": ["emailType", "subject", "recipient", "template", "custom"], "required": true, "default": "emailType" }, "matchValue": { "type": "text", "required": true }, "accountName": { "type": "string", "required": true }, "fallbackAccountName": { "type": "string" } };
+const attributes$5 = { "name": { "type": "string", "required": true, "unique": true }, "description": { "type": "text" }, "isActive": { "type": "boolean", "default": true, "required": true }, "priority": { "type": "integer", "default": 1, "min": 1 }, "matchType": { "type": "enumeration", "enum": ["emailType", "subject", "recipient", "template", "custom"], "required": true, "default": "emailType" }, "matchValue": { "type": "text", "required": true }, "accountName": { "type": "string", "required": true }, "fallbackAccountName": { "type": "string" }, "whatsappFallback": { "type": "boolean", "default": false }, "whatsappPhoneField": { "type": "string" } };
 const require$$1 = {
   kind: kind$5,
   collectionName: collectionName$5,
@@ -394,6 +396,88 @@ function requireController() {
         strapi.log.error("[magic-mail] Error sending email:", err);
         ctx.throw(500, err.message || "Failed to send email");
       }
+    },
+    /**
+     * Send message via Email or WhatsApp (unified API)
+     * POST /api/magic-mail/send-message
+     * Body: { channel: 'email' | 'whatsapp' | 'auto', to, phoneNumber, subject, message, ... }
+     */
+    async sendMessage(ctx) {
+      try {
+        const emailRouter2 = strapi.plugin("magic-mail").service("email-router");
+        const result = await emailRouter2.sendMessage(ctx.request.body);
+        ctx.body = {
+          success: true,
+          ...result
+        };
+      } catch (err) {
+        strapi.log.error("[magic-mail] Error sending message:", err);
+        ctx.throw(500, err.message || "Failed to send message");
+      }
+    },
+    /**
+     * Send WhatsApp message
+     * POST /api/magic-mail/send-whatsapp
+     * Body: { phoneNumber, message, templateId?, templateData? }
+     */
+    async sendWhatsApp(ctx) {
+      try {
+        const emailRouter2 = strapi.plugin("magic-mail").service("email-router");
+        const result = await emailRouter2.sendWhatsApp(ctx.request.body);
+        ctx.body = {
+          success: true,
+          ...result
+        };
+      } catch (err) {
+        strapi.log.error("[magic-mail] Error sending WhatsApp:", err);
+        ctx.throw(500, err.message || "Failed to send WhatsApp message");
+      }
+    },
+    /**
+     * Get WhatsApp connection status
+     * GET /api/magic-mail/whatsapp/status
+     */
+    async getWhatsAppStatus(ctx) {
+      try {
+        const emailRouter2 = strapi.plugin("magic-mail").service("email-router");
+        const status = emailRouter2.getWhatsAppStatus();
+        ctx.body = {
+          success: true,
+          data: status
+        };
+      } catch (err) {
+        strapi.log.error("[magic-mail] Error getting WhatsApp status:", err);
+        ctx.body = {
+          success: false,
+          data: {
+            isConnected: false,
+            status: "error",
+            error: err.message
+          }
+        };
+      }
+    },
+    /**
+     * Check if phone number is on WhatsApp
+     * GET /api/magic-mail/whatsapp/check/:phoneNumber
+     */
+    async checkWhatsAppNumber(ctx) {
+      try {
+        const { phoneNumber } = ctx.params;
+        if (!phoneNumber) {
+          ctx.throw(400, "Phone number is required");
+          return;
+        }
+        const emailRouter2 = strapi.plugin("magic-mail").service("email-router");
+        const result = await emailRouter2.checkWhatsAppNumber(phoneNumber);
+        ctx.body = {
+          success: true,
+          data: result
+        };
+      } catch (err) {
+        strapi.log.error("[magic-mail] Error checking WhatsApp number:", err);
+        ctx.throw(500, err.message || "Failed to check phone number");
+      }
     }
   };
   return controller;
@@ -2444,6 +2528,219 @@ function requireTest() {
   };
   return test;
 }
+var whatsapp$1;
+var hasRequiredWhatsapp$1;
+function requireWhatsapp$1() {
+  if (hasRequiredWhatsapp$1) return whatsapp$1;
+  hasRequiredWhatsapp$1 = 1;
+  whatsapp$1 = {
+    /**
+     * Check if WhatsApp/Baileys is available
+     * GET /magic-mail/whatsapp/available
+     */
+    async checkAvailable(ctx) {
+      try {
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const available = await whatsappService.isAvailable();
+        ctx.body = {
+          success: true,
+          data: {
+            available,
+            message: available ? "WhatsApp integration is available" : "Baileys not installed. Run: npm install @whiskeysockets/baileys pino qrcode"
+          }
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Get WhatsApp connection status
+     * GET /magic-mail/whatsapp/status
+     */
+    async getStatus(ctx) {
+      try {
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const status = whatsappService.getStatus();
+        const sessionInfo = await whatsappService.getSessionInfo();
+        ctx.body = {
+          success: true,
+          data: {
+            ...status,
+            session: sessionInfo
+          }
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Connect to WhatsApp (generates QR code if needed)
+     * POST /magic-mail/whatsapp/connect
+     */
+    async connect(ctx) {
+      try {
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const result = await whatsappService.connect();
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Disconnect from WhatsApp
+     * POST /magic-mail/whatsapp/disconnect
+     */
+    async disconnect(ctx) {
+      try {
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const result = await whatsappService.disconnect();
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Send a test message
+     * POST /magic-mail/whatsapp/send-test
+     */
+    async sendTest(ctx) {
+      try {
+        const { phoneNumber, message } = ctx.request.body;
+        if (!phoneNumber) {
+          return ctx.badRequest("Phone number is required");
+        }
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const testMessage = message || `[MagicMail Test] This is a test message sent at ${(/* @__PURE__ */ new Date()).toLocaleString()}`;
+        const result = await whatsappService.sendMessage(phoneNumber, testMessage);
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Send a message using a template
+     * POST /magic-mail/whatsapp/send-template
+     */
+    async sendTemplateMessage(ctx) {
+      try {
+        const { phoneNumber, templateName, variables } = ctx.request.body;
+        if (!phoneNumber || !templateName) {
+          return ctx.badRequest("Phone number and template name are required");
+        }
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const result = await whatsappService.sendTemplateMessage(phoneNumber, templateName, variables || {});
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Check if a phone number is on WhatsApp
+     * POST /magic-mail/whatsapp/check-number
+     */
+    async checkNumber(ctx) {
+      try {
+        const { phoneNumber } = ctx.request.body;
+        if (!phoneNumber) {
+          return ctx.badRequest("Phone number is required");
+        }
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const result = await whatsappService.checkNumber(phoneNumber);
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Get all WhatsApp templates
+     * GET /magic-mail/whatsapp/templates
+     */
+    async getTemplates(ctx) {
+      try {
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const templates = await whatsappService.getTemplates();
+        ctx.body = {
+          success: true,
+          data: templates
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Save a WhatsApp template
+     * POST /magic-mail/whatsapp/templates
+     */
+    async saveTemplate(ctx) {
+      try {
+        const { templateName, templateContent } = ctx.request.body;
+        if (!templateName || !templateContent) {
+          return ctx.badRequest("Template name and content are required");
+        }
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const result = await whatsappService.saveTemplate(templateName, templateContent);
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Delete a WhatsApp template
+     * DELETE /magic-mail/whatsapp/templates/:templateName
+     */
+    async deleteTemplate(ctx) {
+      try {
+        const { templateName } = ctx.params;
+        if (!templateName) {
+          return ctx.badRequest("Template name is required");
+        }
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const result = await whatsappService.deleteTemplate(templateName);
+        ctx.body = {
+          success: result.success,
+          data: result
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    },
+    /**
+     * Get session info
+     * GET /magic-mail/whatsapp/session
+     */
+    async getSession(ctx) {
+      try {
+        const whatsappService = strapi.plugin("magic-mail").service("whatsapp");
+        const sessionInfo = await whatsappService.getSessionInfo();
+        ctx.body = {
+          success: true,
+          data: sessionInfo
+        };
+      } catch (error) {
+        ctx.throw(500, error.message);
+      }
+    }
+  };
+  return whatsapp$1;
+}
 var controllers;
 var hasRequiredControllers;
 function requireControllers() {
@@ -2457,6 +2754,7 @@ function requireControllers() {
   const emailDesigner2 = requireEmailDesigner$1();
   const analytics2 = requireAnalytics$1();
   const test2 = requireTest();
+  const whatsapp2 = requireWhatsapp$1();
   controllers = {
     controller: controller2,
     accounts: accounts2,
@@ -2465,7 +2763,8 @@ function requireControllers() {
     license: license2,
     emailDesigner: emailDesigner2,
     analytics: analytics2,
-    test: test2
+    test: test2,
+    whatsapp: whatsapp2
   };
   return controllers;
 }
@@ -2940,6 +3239,106 @@ function requireAdmin() {
           policies: ["admin::isAuthenticatedAdmin"],
           description: "Test template-version relations"
         }
+      },
+      // WhatsApp Routes
+      {
+        method: "GET",
+        path: "/whatsapp/available",
+        handler: "whatsapp.checkAvailable",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Check if WhatsApp/Baileys is available"
+        }
+      },
+      {
+        method: "GET",
+        path: "/whatsapp/status",
+        handler: "whatsapp.getStatus",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Get WhatsApp connection status"
+        }
+      },
+      {
+        method: "POST",
+        path: "/whatsapp/connect",
+        handler: "whatsapp.connect",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Connect to WhatsApp (generates QR if needed)"
+        }
+      },
+      {
+        method: "POST",
+        path: "/whatsapp/disconnect",
+        handler: "whatsapp.disconnect",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Disconnect from WhatsApp"
+        }
+      },
+      {
+        method: "POST",
+        path: "/whatsapp/send-test",
+        handler: "whatsapp.sendTest",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Send a test WhatsApp message"
+        }
+      },
+      {
+        method: "POST",
+        path: "/whatsapp/send-template",
+        handler: "whatsapp.sendTemplateMessage",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Send WhatsApp message using template"
+        }
+      },
+      {
+        method: "POST",
+        path: "/whatsapp/check-number",
+        handler: "whatsapp.checkNumber",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Check if phone number is on WhatsApp"
+        }
+      },
+      {
+        method: "GET",
+        path: "/whatsapp/templates",
+        handler: "whatsapp.getTemplates",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Get all WhatsApp message templates"
+        }
+      },
+      {
+        method: "POST",
+        path: "/whatsapp/templates",
+        handler: "whatsapp.saveTemplate",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Save a WhatsApp message template"
+        }
+      },
+      {
+        method: "DELETE",
+        path: "/whatsapp/templates/:templateName",
+        handler: "whatsapp.deleteTemplate",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Delete a WhatsApp message template"
+        }
+      },
+      {
+        method: "GET",
+        path: "/whatsapp/session",
+        handler: "whatsapp.getSession",
+        config: {
+          policies: ["admin::isAuthenticatedAdmin"],
+          description: "Get WhatsApp session info"
+        }
       }
     ]
   };
@@ -2953,6 +3352,7 @@ function requireContentApi() {
   contentApi = {
     type: "content-api",
     routes: [
+      // ============= EMAIL ROUTES =============
       {
         method: "POST",
         path: "/send",
@@ -2963,7 +3363,45 @@ function requireContentApi() {
           description: "Send email via MagicMail router"
         }
       },
-      // Public tracking endpoints (no auth required!)
+      // ============= UNIFIED MESSAGE ROUTE =============
+      {
+        method: "POST",
+        path: "/send-message",
+        handler: "controller.sendMessage",
+        config: {
+          auth: false,
+          description: "Send message via Email or WhatsApp (unified API)"
+        }
+      },
+      // ============= WHATSAPP ROUTES =============
+      {
+        method: "POST",
+        path: "/send-whatsapp",
+        handler: "controller.sendWhatsApp",
+        config: {
+          auth: false,
+          description: "Send WhatsApp message"
+        }
+      },
+      {
+        method: "GET",
+        path: "/whatsapp/status",
+        handler: "controller.getWhatsAppStatus",
+        config: {
+          auth: false,
+          description: "Get WhatsApp connection status"
+        }
+      },
+      {
+        method: "GET",
+        path: "/whatsapp/check/:phoneNumber",
+        handler: "controller.checkWhatsAppNumber",
+        config: {
+          auth: false,
+          description: "Check if phone number is on WhatsApp"
+        }
+      },
+      // ============= TRACKING ROUTES =============
       {
         method: "GET",
         path: "/track/open/:emailId/:recipientHash",
@@ -3208,6 +3646,39 @@ function requireEmailRouter() {
       emailData.html = html;
       emailData.text = text;
       emailData.subject = subject;
+      let matchedRule = null;
+      try {
+        const allRules = await strapi2.documents("plugin::magic-mail.routing-rule").findMany({
+          filters: { isActive: true },
+          sort: [{ priority: "desc" }]
+        });
+        for (const rule of allRules) {
+          let matches = false;
+          switch (rule.matchType) {
+            case "emailType":
+              matches = rule.matchValue === type;
+              break;
+            case "recipient":
+              matches = to && to.toLowerCase().includes(rule.matchValue.toLowerCase());
+              break;
+            case "subject":
+              matches = subject && subject.toLowerCase().includes(rule.matchValue.toLowerCase());
+              break;
+            case "template":
+              matches = emailData.template && emailData.template === rule.matchValue;
+              break;
+            case "custom":
+              matches = emailData.customField && emailData.customField === rule.matchValue;
+              break;
+          }
+          if (matches) {
+            matchedRule = rule;
+            break;
+          }
+        }
+      } catch (ruleError) {
+        strapi2.log.warn("[magic-mail] [WARNING] Failed to check routing rules for WhatsApp fallback:", ruleError.message);
+      }
       try {
         const licenseGuard2 = strapi2.plugin("magic-mail").service("license-guard");
         if (priority === "high") {
@@ -3258,6 +3729,38 @@ function requireEmailRouter() {
         };
       } catch (error) {
         strapi2.log.error("[magic-mail] [ERROR] Email send failed:", error);
+        if (matchedRule?.whatsappFallback) {
+          strapi2.log.info("[magic-mail] [FALLBACK] Email failed, attempting WhatsApp fallback...");
+          try {
+            const whatsapp2 = strapi2.plugin("magic-mail").service("whatsapp");
+            const whatsappStatus = whatsapp2.getStatus();
+            if (whatsappStatus.isConnected) {
+              const phoneNumber = emailData.phoneNumber || emailData.whatsappPhone;
+              if (phoneNumber) {
+                const whatsappMessage = `*${subject}*
+
+${text || "Email delivery failed. Please check your email settings."}`;
+                const waResult = await whatsapp2.sendMessage(phoneNumber, whatsappMessage);
+                if (waResult.success) {
+                  strapi2.log.info(`[magic-mail] [SUCCESS] WhatsApp fallback sent to ${phoneNumber}`);
+                  return {
+                    success: true,
+                    fallbackUsed: "whatsapp",
+                    phoneNumber
+                  };
+                } else {
+                  strapi2.log.warn("[magic-mail] [WARNING] WhatsApp fallback failed:", waResult.error);
+                }
+              } else {
+                strapi2.log.warn("[magic-mail] [WARNING] WhatsApp fallback enabled but no phone number provided");
+              }
+            } else {
+              strapi2.log.warn("[magic-mail] [WARNING] WhatsApp fallback enabled but WhatsApp not connected");
+            }
+          } catch (waError) {
+            strapi2.log.error("[magic-mail] [ERROR] WhatsApp fallback error:", waError.message);
+          }
+        }
         throw error;
       }
     },
@@ -4166,6 +4669,168 @@ function requireEmailRouter() {
           ...headers
         }
       };
+    },
+    // ============================================================================
+    // UNIFIED MESSAGE API - Send via Email OR WhatsApp
+    // ============================================================================
+    /**
+     * Send a message via WhatsApp
+     * Same pattern as send() but for WhatsApp
+     * @param {Object} messageData - { phoneNumber, message, templateId, templateData }
+     * @returns {Promise<Object>} Send result
+     */
+    async sendWhatsApp(messageData) {
+      const {
+        phoneNumber,
+        message,
+        templateId = null,
+        templateData = {}
+      } = messageData;
+      if (!phoneNumber) {
+        throw new Error("Phone number is required for WhatsApp messages");
+      }
+      const cleanPhone = phoneNumber.replace(/[^\d]/g, "");
+      if (cleanPhone.length < 10) {
+        throw new Error("Invalid phone number format. Use format: 491234567890 (country code + number)");
+      }
+      const whatsapp2 = strapi2.plugin("magic-mail").service("whatsapp");
+      const status = whatsapp2.getStatus();
+      if (!status.isConnected) {
+        throw new Error("WhatsApp is not connected. Please connect WhatsApp first in the admin panel.");
+      }
+      let finalMessage = message;
+      if (templateId) {
+        try {
+          const template = await whatsapp2.getTemplate(templateId);
+          if (template) {
+            finalMessage = template.content;
+            Object.keys(templateData).forEach((key) => {
+              finalMessage = finalMessage.replace(new RegExp(`{{${key}}}`, "g"), templateData[key]);
+            });
+          }
+        } catch (error) {
+          strapi2.log.warn(`[magic-mail] WhatsApp template ${templateId} not found, using plain message`);
+        }
+      }
+      if (!finalMessage) {
+        throw new Error("Message content is required");
+      }
+      strapi2.log.info(`[magic-mail] [WHATSAPP] Sending message to ${cleanPhone}`);
+      const result = await whatsapp2.sendMessage(cleanPhone, finalMessage);
+      if (result.success) {
+        strapi2.log.info(`[magic-mail] [SUCCESS] WhatsApp message sent to ${cleanPhone}`);
+        return {
+          success: true,
+          channel: "whatsapp",
+          phoneNumber: cleanPhone,
+          jid: result.jid
+        };
+      } else {
+        strapi2.log.error(`[magic-mail] [ERROR] WhatsApp send failed: ${result.error}`);
+        throw new Error(result.error || "Failed to send WhatsApp message");
+      }
+    },
+    /**
+     * Unified send method - automatically chooses Email or WhatsApp
+     * @param {Object} messageData - Combined email and WhatsApp data
+     * @param {string} messageData.channel - 'email' | 'whatsapp' | 'auto' (default: 'auto')
+     * @param {string} messageData.to - Email address (for email channel)
+     * @param {string} messageData.phoneNumber - Phone number (for whatsapp channel)
+     * @param {string} messageData.subject - Email subject
+     * @param {string} messageData.message - Plain text message (used for WhatsApp, or as email text)
+     * @param {string} messageData.html - HTML content (email only)
+     * @param {string} messageData.templateId - Template ID (works for both channels)
+     * @param {Object} messageData.templateData - Template variables
+     * @returns {Promise<Object>} Send result with channel info
+     */
+    async sendMessage(messageData) {
+      const {
+        channel = "auto",
+        to,
+        phoneNumber,
+        subject,
+        message,
+        text,
+        html,
+        templateId,
+        templateData,
+        ...rest
+      } = messageData;
+      let useChannel = channel;
+      if (channel === "auto") {
+        if (to && to.includes("@")) {
+          useChannel = "email";
+        } else if (phoneNumber) {
+          useChannel = "whatsapp";
+        } else {
+          throw new Error("Either email (to) or phoneNumber is required");
+        }
+      }
+      strapi2.log.info(`[magic-mail] [SEND] Channel: ${useChannel}, to: ${to || phoneNumber}`);
+      if (useChannel === "whatsapp") {
+        if (!phoneNumber) {
+          throw new Error("Phone number is required for WhatsApp channel");
+        }
+        return await this.sendWhatsApp({
+          phoneNumber,
+          message: message || text || subject,
+          // Use message, fallback to text or subject
+          templateId,
+          templateData
+        });
+      } else {
+        if (!to) {
+          throw new Error("Email address (to) is required for email channel");
+        }
+        const result = await this.send({
+          to,
+          subject,
+          text: text || message,
+          html,
+          templateId,
+          templateData,
+          phoneNumber,
+          // Pass for WhatsApp fallback
+          ...rest
+        });
+        return {
+          ...result,
+          channel: "email"
+        };
+      }
+    },
+    /**
+     * Check WhatsApp connection status
+     * @returns {Object} Connection status
+     */
+    getWhatsAppStatus() {
+      try {
+        const whatsapp2 = strapi2.plugin("magic-mail").service("whatsapp");
+        return whatsapp2.getStatus();
+      } catch (error) {
+        return {
+          isConnected: false,
+          status: "unavailable",
+          error: error.message
+        };
+      }
+    },
+    /**
+     * Check if a phone number is registered on WhatsApp
+     * @param {string} phoneNumber - Phone number to check
+     * @returns {Promise<Object>} Check result
+     */
+    async checkWhatsAppNumber(phoneNumber) {
+      try {
+        const whatsapp2 = strapi2.plugin("magic-mail").service("whatsapp");
+        return await whatsapp2.checkNumber(phoneNumber);
+      } catch (error) {
+        return {
+          success: false,
+          exists: false,
+          error: error.message
+        };
+      }
     }
   });
   return emailRouter;
@@ -4862,7 +5527,7 @@ function requireOauth() {
   });
   return oauth;
 }
-const version = "2.2.4";
+const version = "2.4.0";
 const require$$2 = {
   version
 };
@@ -6166,6 +6831,434 @@ function requireAnalytics() {
   });
   return analytics;
 }
+var whatsapp;
+var hasRequiredWhatsapp;
+function requireWhatsapp() {
+  if (hasRequiredWhatsapp) return whatsapp;
+  hasRequiredWhatsapp = 1;
+  const path = require$$0$4;
+  const fs = require$$1$3;
+  let baileys = null;
+  const loadBaileys = async () => {
+    if (!baileys) {
+      try {
+        baileys = require("@whiskeysockets/baileys");
+        if (process.env.DEBUG) {
+          console.log("[MagicMail WhatsApp] Baileys loaded successfully");
+        }
+        return true;
+      } catch (error) {
+        console.warn("[MagicMail WhatsApp] Baileys not installed. WhatsApp features disabled.");
+        console.warn("[MagicMail WhatsApp] Install with: npm install @whiskeysockets/baileys pino qrcode");
+        return false;
+      }
+    }
+    return true;
+  };
+  whatsapp = ({ strapi: strapi2 }) => {
+    let sock = null;
+    let qrCode = null;
+    let connectionStatus = "disconnected";
+    let lastError = null;
+    let eventListeners = [];
+    let wasConnectedBefore = false;
+    let reconnectAttempts = 0;
+    const MAX_RECONNECT_ATTEMPTS = 3;
+    const isDebugEnabled = async () => {
+      try {
+        const pluginStore = strapi2.store({ type: "plugin", name: "magic-mail" });
+        const settings = await pluginStore.get({ key: "settings" });
+        return settings?.whatsapp_debug === true;
+      } catch {
+        return false;
+      }
+    };
+    const debugLog = async (message) => {
+      if (await isDebugEnabled()) {
+        strapi2.log.info(message);
+      }
+    };
+    const getAuthPath = () => {
+      const strapiRoot = strapi2.dirs?.app?.root || process.cwd();
+      return path.join(strapiRoot, ".magicmail-whatsapp-auth");
+    };
+    const emit = (event, data) => {
+      eventListeners.forEach((listener) => {
+        try {
+          listener(event, data);
+        } catch (e) {
+          console.error("[MagicMail WhatsApp] Event listener error:", e);
+        }
+      });
+    };
+    const service = {
+      /**
+       * Check if Baileys is available
+       * @returns {Promise<boolean>} True if Baileys is installed
+       */
+      async isAvailable() {
+        return await loadBaileys();
+      },
+      /**
+       * Get current connection status
+       * @returns {object} Status object with status, qrCode, lastError, isConnected
+       */
+      getStatus() {
+        return {
+          status: connectionStatus,
+          qrCode,
+          lastError,
+          isConnected: connectionStatus === "connected"
+        };
+      },
+      /**
+       * Add event listener for WhatsApp events
+       * @param {function} callback - Callback function(event, data)
+       * @returns {function} Unsubscribe function
+       */
+      on(callback) {
+        eventListeners.push(callback);
+        return () => {
+          eventListeners = eventListeners.filter((l) => l !== callback);
+        };
+      },
+      /**
+       * Initialize WhatsApp connection
+       * @returns {Promise<object>} Connection result with success status
+       */
+      async connect() {
+        const available = await loadBaileys();
+        if (!available) {
+          lastError = "Baileys not installed. Run: npm install @whiskeysockets/baileys pino qrcode";
+          strapi2.log.error("[MagicMail WhatsApp] [ERROR] Baileys library not available");
+          return { success: false, error: lastError };
+        }
+        if (sock && connectionStatus === "connected") {
+          await debugLog("[MagicMail WhatsApp] Already connected");
+          return { success: true, status: "already_connected" };
+        }
+        if (sock) {
+          try {
+            sock.end();
+          } catch (e) {
+          }
+          sock = null;
+        }
+        return new Promise(async (resolve) => {
+          try {
+            connectionStatus = "connecting";
+            emit("status", { status: connectionStatus });
+            await debugLog("[MagicMail WhatsApp] Starting connection...");
+            const authPath = getAuthPath();
+            if (!fs.existsSync(authPath)) {
+              fs.mkdirSync(authPath, { recursive: true });
+            }
+            await debugLog(`[MagicMail WhatsApp] Auth path: ${authPath}`);
+            const { state, saveCreds } = await baileys.useMultiFileAuthState(authPath);
+            await debugLog("[MagicMail WhatsApp] Auth state loaded");
+            const pino = require("pino");
+            const logger2 = pino({ level: "silent" });
+            await debugLog("[MagicMail WhatsApp] Creating WhatsApp socket...");
+            const makeSocket = baileys.default || baileys.makeWASocket;
+            const browserConfig = baileys.Browsers.ubuntu("Chrome");
+            await debugLog(`[MagicMail WhatsApp] Browser config: ${JSON.stringify(browserConfig)}`);
+            sock = makeSocket({
+              auth: state,
+              logger: logger2,
+              browser: browserConfig,
+              syncFullHistory: false,
+              markOnlineOnConnect: false,
+              generateHighQualityLinkPreview: false,
+              getMessage: async (key) => {
+                return { conversation: "" };
+              }
+            });
+            await debugLog("[MagicMail WhatsApp] Socket created, registering event handlers...");
+            let resolved = false;
+            const resolveOnce = (result) => {
+              if (!resolved) {
+                resolved = true;
+                resolve(result);
+              }
+            };
+            setTimeout(() => {
+              if (!resolved) {
+                strapi2.log.warn("[MagicMail WhatsApp] Connection timeout - no QR or connection");
+                resolveOnce({ success: true, status: connectionStatus, qrCode });
+              }
+            }, 3e4);
+            sock.ev.on("connection.update", async (update) => {
+              await debugLog(`[MagicMail WhatsApp] connection.update: ${JSON.stringify(update)}`);
+              const { connection, lastDisconnect, qr } = update;
+              if (qr) {
+                await debugLog("[MagicMail WhatsApp] QR code received");
+                try {
+                  const QRCode = require("qrcode");
+                  qrCode = await QRCode.toDataURL(qr);
+                  connectionStatus = "qr_pending";
+                  emit("qr", { qrCode });
+                  emit("status", { status: connectionStatus });
+                  strapi2.log.info("[MagicMail WhatsApp] [SUCCESS] QR Code generated - scan with WhatsApp");
+                  resolveOnce({ success: true, status: connectionStatus, qrCode });
+                } catch (qrError) {
+                  strapi2.log.error("[MagicMail WhatsApp] QR generation error:", qrError.message);
+                }
+              }
+              if (connection === "close") {
+                const statusCode = lastDisconnect?.error?.output?.statusCode;
+                const isLoggedOut = statusCode === baileys.DisconnectReason.loggedOut;
+                const isRestartRequired = statusCode === baileys.DisconnectReason.restartRequired;
+                const isConnectionFailure = statusCode === 405;
+                await debugLog(`[MagicMail WhatsApp] Connection closed - statusCode: ${statusCode}`);
+                if (isLoggedOut) {
+                  connectionStatus = "disconnected";
+                  lastError = "Logged out from WhatsApp";
+                  qrCode = null;
+                  wasConnectedBefore = false;
+                  reconnectAttempts = 0;
+                  try {
+                    fs.rmSync(authPath, { recursive: true, force: true });
+                  } catch (e) {
+                  }
+                  strapi2.log.warn("[MagicMail WhatsApp] Logged out - auth cleared");
+                } else if (isRestartRequired) {
+                  await debugLog("[MagicMail WhatsApp] Restart required - reconnecting...");
+                  connectionStatus = "connecting";
+                  setTimeout(() => {
+                    service.connect();
+                  }, 1e3);
+                } else if (isConnectionFailure && reconnectAttempts < 2) {
+                  reconnectAttempts++;
+                  await debugLog(`[MagicMail WhatsApp] Connection rejected (405) - retrying (${reconnectAttempts}/2)`);
+                  try {
+                    fs.rmSync(authPath, { recursive: true, force: true });
+                  } catch (e) {
+                  }
+                  connectionStatus = "disconnected";
+                  qrCode = null;
+                  setTimeout(() => {
+                    service.connect();
+                  }, 3e3);
+                } else if (isConnectionFailure) {
+                  connectionStatus = "disconnected";
+                  lastError = "WhatsApp connection rejected (405). Please try again later.";
+                  strapi2.log.error("[MagicMail WhatsApp] [ERROR] Connection rejected after retries.");
+                  resolveOnce({ success: false, status: connectionStatus, error: lastError });
+                } else if (wasConnectedBefore && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+                  reconnectAttempts++;
+                  connectionStatus = "connecting";
+                  await debugLog(`[MagicMail WhatsApp] Reconnecting (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})...`);
+                  setTimeout(() => {
+                    service.connect();
+                  }, 3e3 * reconnectAttempts);
+                } else if (!wasConnectedBefore) {
+                  connectionStatus = "disconnected";
+                  qrCode = null;
+                  await debugLog("[MagicMail WhatsApp] Connection closed - waiting for QR scan");
+                } else {
+                  connectionStatus = "disconnected";
+                  lastError = "Max reconnect attempts reached";
+                  strapi2.log.warn("[MagicMail WhatsApp] Max reconnect attempts reached");
+                }
+                emit("status", { status: connectionStatus, error: lastError });
+              }
+              if (connection === "open") {
+                connectionStatus = "connected";
+                qrCode = null;
+                lastError = null;
+                wasConnectedBefore = true;
+                reconnectAttempts = 0;
+                emit("status", { status: connectionStatus });
+                strapi2.log.info("[MagicMail WhatsApp] [SUCCESS] Connected successfully!");
+                resolveOnce({ success: true, status: connectionStatus });
+              }
+            });
+            sock.ev.on("creds.update", saveCreds);
+          } catch (error) {
+            lastError = error.message;
+            connectionStatus = "disconnected";
+            strapi2.log.error("[MagicMail WhatsApp] Connection error:", error);
+            resolve({ success: false, error: error.message });
+          }
+        });
+      },
+      /**
+       * Disconnect WhatsApp and clear session
+       * @returns {Promise<object>} Result with success status
+       */
+      async disconnect() {
+        if (sock) {
+          try {
+            await sock.logout();
+          } catch (e) {
+          }
+          sock = null;
+        }
+        connectionStatus = "disconnected";
+        qrCode = null;
+        emit("status", { status: connectionStatus });
+        strapi2.log.info("[MagicMail WhatsApp] Disconnected");
+        return { success: true };
+      },
+      /**
+       * Send a text message to a phone number
+       * @param {string} phoneNumber - Phone number with country code (e.g., "491234567890")
+       * @param {string} message - Message text
+       * @returns {Promise<object>} Result with success status
+       */
+      async sendMessage(phoneNumber, message) {
+        if (connectionStatus !== "connected" || !sock) {
+          return {
+            success: false,
+            error: "WhatsApp not connected. Please connect first."
+          };
+        }
+        try {
+          const formattedNumber = phoneNumber.replace(/[^\d]/g, "");
+          const jid = `${formattedNumber}@s.whatsapp.net`;
+          const [exists] = await sock.onWhatsApp(formattedNumber);
+          if (!exists?.exists) {
+            return {
+              success: false,
+              error: `Phone number ${phoneNumber} is not registered on WhatsApp`
+            };
+          }
+          await sock.sendMessage(jid, { text: message });
+          await debugLog(`[MagicMail WhatsApp] Message sent to ${formattedNumber}`);
+          return { success: true, jid };
+        } catch (error) {
+          strapi2.log.error("[MagicMail WhatsApp] Send error:", error);
+          return { success: false, error: error.message };
+        }
+      },
+      /**
+       * Send message using a template
+       * @param {string} phoneNumber - Phone number
+       * @param {string} templateName - Template identifier
+       * @param {object} variables - Template variables to replace
+       * @returns {Promise<object>} Result with success status
+       */
+      async sendTemplateMessage(phoneNumber, templateName, variables = {}) {
+        try {
+          const pluginStore = strapi2.store({ type: "plugin", name: "magic-mail" });
+          const templates = await pluginStore.get({ key: "whatsapp_templates" }) || {};
+          let template = templates[templateName];
+          if (!template) {
+            template = `*{{subject}}*
+
+{{body}}`;
+          }
+          let message = template;
+          for (const [key, value] of Object.entries(variables)) {
+            message = message.replace(new RegExp(`{{${key}}}`, "g"), value);
+          }
+          return this.sendMessage(phoneNumber, message);
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+      /**
+       * Check if a phone number is on WhatsApp
+       * @param {string} phoneNumber - Phone number to check
+       * @returns {Promise<object>} Result with exists boolean
+       */
+      async checkNumber(phoneNumber) {
+        if (connectionStatus !== "connected" || !sock) {
+          return { success: false, error: "WhatsApp not connected" };
+        }
+        try {
+          const formattedNumber = phoneNumber.replace(/[^\d]/g, "");
+          const [result] = await sock.onWhatsApp(formattedNumber);
+          return {
+            success: true,
+            exists: result?.exists || false,
+            jid: result?.jid
+          };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+      /**
+       * Get session info
+       * @returns {Promise<object|null>} Session info or null if not connected
+       */
+      async getSessionInfo() {
+        if (connectionStatus !== "connected" || !sock) {
+          return null;
+        }
+        try {
+          const user = sock.user;
+          return {
+            phoneNumber: user?.id?.split(":")[0] || user?.id?.split("@")[0],
+            name: user?.name,
+            platform: "WhatsApp Web"
+          };
+        } catch (error) {
+          return null;
+        }
+      },
+      /**
+       * Reset connection state (for manual cleanup)
+       */
+      reset() {
+        sock = null;
+        qrCode = null;
+        connectionStatus = "disconnected";
+        lastError = null;
+        wasConnectedBefore = false;
+        reconnectAttempts = 0;
+      },
+      /**
+       * Save WhatsApp template
+       * @param {string} templateName - Template identifier
+       * @param {string} templateContent - Template content with {{variables}}
+       * @returns {Promise<object>} Result with success status
+       */
+      async saveTemplate(templateName, templateContent) {
+        try {
+          const pluginStore = strapi2.store({ type: "plugin", name: "magic-mail" });
+          const templates = await pluginStore.get({ key: "whatsapp_templates" }) || {};
+          templates[templateName] = templateContent;
+          await pluginStore.set({ key: "whatsapp_templates", value: templates });
+          return { success: true };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      },
+      /**
+       * Get all WhatsApp templates
+       * @returns {Promise<object>} Templates object
+       */
+      async getTemplates() {
+        try {
+          const pluginStore = strapi2.store({ type: "plugin", name: "magic-mail" });
+          const templates = await pluginStore.get({ key: "whatsapp_templates" }) || {};
+          return templates;
+        } catch (error) {
+          return {};
+        }
+      },
+      /**
+       * Delete a WhatsApp template
+       * @param {string} templateName - Template identifier
+       * @returns {Promise<object>} Result with success status
+       */
+      async deleteTemplate(templateName) {
+        try {
+          const pluginStore = strapi2.store({ type: "plugin", name: "magic-mail" });
+          const templates = await pluginStore.get({ key: "whatsapp_templates" }) || {};
+          delete templates[templateName];
+          await pluginStore.set({ key: "whatsapp_templates", value: templates });
+          return { success: true };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      }
+    };
+    return service;
+  };
+  return whatsapp;
+}
 var services;
 var hasRequiredServices;
 function requireServices() {
@@ -6177,13 +7270,15 @@ function requireServices() {
   const licenseGuard2 = requireLicenseGuard();
   const emailDesigner2 = requireEmailDesigner();
   const analytics2 = requireAnalytics();
+  const whatsapp2 = requireWhatsapp();
   services = {
     "email-router": emailRouter2,
     "account-manager": accountManager2,
     oauth: oauth2,
     "license-guard": licenseGuard2,
     "email-designer": emailDesigner2,
-    analytics: analytics2
+    analytics: analytics2,
+    whatsapp: whatsapp2
   };
   return services;
 }