@peopl-health/nexus 2.7.0 → 2.8.0-fix.1

package/lib/adapters/BaileysProvider.js

@@ -1,5 +1,6 @@
 const { MessageProvider } = require('../core/MessageProvider');
 const { logger } = require('../utils/logger');
+const { calculateDelay } = require('../utils/scheduleUtils');
 
 /**
  * Baileys WhatsApp messaging provider
@@ -150,7 +151,7 @@ class BaileysProvider extends MessageProvider {
 
   async sendScheduledMessage(scheduledMessage) {
     const { sendTime, timeZone, __nexusSend } = scheduledMessage;
-    const delay = this.calculateDelay(sendTime, timeZone);
+    const delay = calculateDelay(sendTime, timeZone);
 
     const sender = typeof __nexusSend === 'function'
       ? __nexusSend
@@ -181,11 +182,6 @@ class BaileysProvider extends MessageProvider {
     return { scheduled: true, delay };
   }
 
-  calculateDelay(sendTime) {
-    const now = new Date();
-    const targetTime = new Date(sendTime);
-    return Math.max(0, targetTime.getTime() - now.getTime());
-  }
 
   getConnectionStatus() {
     return this.waSocket?.user ? true : false;

package/lib/adapters/TwilioProvider.js

@@ -3,10 +3,11 @@ const axios = require('axios');
 const runtimeConfig = require('../config/runtimeConfig');
 const { uploadMediaToS3, getFileExtension } = require('../helpers/mediaHelper');
 const { ensureWhatsAppFormat } = require('../helpers/twilioHelper');
-const { sanitizeMediaFilename } = require('../utils/sanitizer');
+const { sanitizeMediaFilename } = require('../utils/inputSanitizer');
 const { generatePresignedUrl } = require('../config/awsConfig');
 const { validateMedia, getMediaType } = require('../utils/mediaValidator');
 const { logger } = require('../utils/logger');
+const { calculateDelay } = require('../utils/scheduleUtils');
 const { v4: uuidv4 } = require('uuid');
 
 /**
@@ -220,7 +221,7 @@ class TwilioProvider extends MessageProvider {
 
   async sendScheduledMessage(scheduledMessage) {
     const { sendTime, timeZone, __nexusSend } = scheduledMessage;
-    const delay = this.calculateDelay(sendTime, timeZone);
+    const delay = calculateDelay(sendTime, timeZone);
 
     const sender = typeof __nexusSend === 'function'
       ? __nexusSend
@@ -423,11 +424,6 @@ class TwilioProvider extends MessageProvider {
     }
   }
 
-  calculateDelay(sendTime) {
-    const now = new Date();
-    const targetTime = new Date(sendTime);
-    return Math.max(0, targetTime.getTime() - now.getTime());
-  }
 
   /**
    * Split a message into chunks at sentence boundaries, respecting Twilio's character limit

package/lib/controllers/bugReportController.js

@@ -46,8 +46,8 @@ const reportBugController = async (req, res) => {
 
     if (!reporter) return res.status(400).json({ success: false, error: 'Reporter username is required' });
     if (!whatsapp_id) return res.status(400).json({ success: false, error: 'WhatsApp ID is required' });
-    if (!severity || !['low', 'medium', 'high'].includes(severity)) {
-      return res.status(400).json({ success: false, error: 'Severity must be low, medium, or high' });
+    if (!severity || !['low', 'medium', 'high', 'critical'].includes(severity)) {
+      return res.status(400).json({ success: false, error: 'Severity must be low, medium, high, or critical' });
     }
 
     logBugReportToAirtable(reporter, whatsapp_id, description, severity, messages).catch(err =>

package/lib/controllers/messageStatusController.js

@@ -63,6 +63,7 @@ async function getMessageStatusController(req, res) {
         message: {
           messageSid: message.message_id,
           statusInfo: message.statusInfo || null,
+          recoveryInfo: message.recoveryInfo || null,
           numero: message.numero,
           body: message.body
         }

package/lib/core/NexusMessaging.js

@@ -43,9 +43,14 @@ class NexusMessaging {
     };
     // Message processing with check-after strategy
     this.processingLocks = new Map(); // Per-chat locks to prevent parallel processing
+    this.activeRequests = new Map(); // Track active AI requests per chat
+    this.abandonedRuns = new Set(); // Track runs that should be ignored
     this.batchingConfig = {
       enabled: config.messageBatching?.enabled ?? true, // Enabled by default with check-after
-      checkDelayMs: config.messageBatching?.checkDelayMs ?? 100 // Delay before checking for new messages
+      abortOnNewMessage: config.messageBatching?.abortOnNewMessage ?? true, // Abort ongoing AI calls when new messages arrive
+      immediateRestart: config.messageBatching?.immediateRestart ?? true, // Start new processing immediately without waiting
+      batchWindowMs: config.messageBatching?.batchWindowMs ?? 2000, // Wait up to 2s for message bursts
+      maxBatchWait: config.messageBatching?.maxBatchWait ?? 5000 // Maximum time to wait for batching
     };
   }
 
@@ -348,6 +353,7 @@ class NexusMessaging {
     if (this.messageStorage) {
       await this.messageStorage.saveMessage({
         ...messageData,
+        messageId: messageData.id,
         timestamp: new Date(),
         fromMe: false,
         origin: 'patient'
@@ -651,49 +657,83 @@ class NexusMessaging {
    * Handle message with check-after strategy - process immediately, check for new messages after
    */
   async _handleWithCheckAfter(chatId) {
-    // If already processing this chat, just return (message is saved, will be picked up)
+    const typingInterval = await this._startTypingRefresh(chatId);
+    
     if (this.processingLocks.has(chatId)) {
       logger.info(`[CheckAfter] Already processing ${chatId}, new message will be included`);
+      
+      if (this.batchingConfig.abortOnNewMessage && this.activeRequests.has(chatId)) {
+        const runId = this.activeRequests.get(chatId);
+        this.abandonedRuns.add(runId);
+        logger.info(`[CheckAfter] Marked run ${runId} as abandoned for ${chatId}`);
+        
+        if (this.batchingConfig.immediateRestart) {
+          this.processingLocks.delete(chatId);
+          this.activeRequests.delete(chatId);
+          
+          logger.info(`[CheckAfter] Starting immediate reprocessing for ${chatId}`);
+          await this._processWithLock(chatId, null);
+        }
+      }
       return;
     }
 
-    await this._processWithLock(chatId);
+    await this._processWithLock(chatId, typingInterval);
   }
 
   /**
    * Process messages with per-chat lock and check-after logic
    */
-  async _processWithLock(chatId) {
+  async _processWithLock(chatId, existingTypingInterval = null) {
     this.processingLocks.set(chatId, true);
-    let typingInterval = null;
+    let typingInterval = existingTypingInterval;
+    let runId = null;
 
     try {
-      typingInterval = await this._startTypingRefresh(chatId);
-      logger.info(`[CheckAfter] Processing messages for ${chatId}`);
+      if (!typingInterval) {
+        typingInterval = await this._startTypingRefresh(chatId);
+      }
+      
+      const startTime = Date.now();
+      let messageCount = await this._getUnprocessedMessageCount(chatId);
+      let lastCount = messageCount;
+      
+      while (Date.now() - startTime < this.batchingConfig.batchWindowMs) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+        const newCount = await this._getUnprocessedMessageCount(chatId);
+        
+        if (newCount > lastCount) {
+          lastCount = newCount;
+          logger.info(`[Batching] New message detected for ${chatId}, extending wait`);
+        }
+        
+        if (Date.now() - startTime >= this.batchingConfig.maxBatchWait) {
+          logger.info(`[Batching] Max wait reached for ${chatId}`);
+          break;
+        }
+      }
+      
+      logger.info(`[CheckAfter] Processing ${lastCount} messages for ${chatId} after batching`);
 
-      // Process with assistant
-      const result = await replyAssistant(chatId);
+      runId = `run_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+      this.activeRequests.set(chatId, runId);
+
+      const result = await replyAssistant(chatId, null, null, { runId });
+      
+      if (this.abandonedRuns.has(runId)) {
+        logger.info(`[CheckAfter] Discarding abandoned run ${runId} for ${chatId}`);
+        this.abandonedRuns.delete(runId);
+        return;
+      }
+      
       const botResponse = typeof result === 'string' ? result : result?.output;
       const tools_executed = typeof result === 'object' ? result?.tools_executed : undefined;
 
-      // Small delay to catch very recent DB writes
-      await new Promise(resolve => setTimeout(resolve, this.batchingConfig.checkDelayMs));
-
-      // Check for new unprocessed messages
-      const hasNewMessages = await Message.exists({
-        numero: chatId,
-        processed: false,
-        from_me: false
-      });
-
-      if (hasNewMessages) {
-        logger.info(`[CheckAfter] New messages detected for ${chatId}, discarding response and reprocessing`);
-        if (typingInterval) clearInterval(typingInterval);
-        // Recursively process with new messages
-        return await this._processWithLock(chatId);
+      if (typingInterval) {
+        clearInterval(typingInterval);
+        typingInterval = null;
       }
 
-      // No new messages - send response and mark processed
       if (botResponse) {
         await this.sendMessage({
           code: chatId,
@@ -711,9 +751,25 @@ class NexusMessaging {
     } finally {
       if (typingInterval) clearInterval(typingInterval);
       this.processingLocks.delete(chatId);
+      this.activeRequests.delete(chatId);
+      if (this.abandonedRuns.size > 100) {
+        this.abandonedRuns.clear();
+      }
     }
   }
 
+  /**
+   * Get count of unprocessed messages for a chat
+   */
+  async _getUnprocessedMessageCount(chatId) {
+    const { Message } = require('../models/messageModel');
+    return await Message.countDocuments({
+      numero: chatId,
+      processed: false,
+      from_me: false
+    });
+  }
+
   /**
    * Start typing indicator refresh interval
    */
@@ -725,10 +781,16 @@ class NexusMessaging {
     const lastMessage = await Message.findOne({ 
       numero: chatId, 
       from_me: false,
-      message_id: { $exists: true, $ne: null }
+      message_id: { $exists: true, $ne: null, $not: /^pending-/ },
+      createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
     }).sort({ createdAt: -1 });
     
-    if (!lastMessage?.message_id) return null;
+    if (!lastMessage?.message_id) {
+      logger.debug(`[_startTypingRefresh] No valid message for typing indicator: ${chatId}`);
+      return null;
+    }
+    
+    logger.debug(`[_startTypingRefresh] Starting typing indicator for message: ${lastMessage.message_id}`);
     
     return setInterval(() => 
       this.provider.sendTypingIndicator(lastMessage.message_id).catch(err => 

package/lib/helpers/filesHelper.js

@@ -7,7 +7,7 @@ const sharp = require('sharp');
 
 const { downloadFileFromS3 } = require('../config/awsConfig.js');
 const { Message } = require('../models/messageModel.js');
-const { sanitizeFilename } = require('../utils/sanitizer.js');
+const { sanitizeFilename } = require('../utils/inputSanitizer.js');
 const { logger } = require('../utils/logger');
 
 async function convertPdfToImages(pdfName, existingPdfPath = null) {
@@ -182,7 +182,11 @@ async function downloadMediaAndCreateFile(code, reply) {
     
     const sanitizedCode = sanitizeFilename(code, 20);
     const sanitizedSubType = sanitizeFilename(subType, 10);
-    const sanitizedFileName = sanitizeFilename(fileName, 50);
+    
+    const fileExt = path.extname(fileName);
+    const fileBaseName = path.basename(fileName, fileExt);
+    const sanitizedBaseName = sanitizeFilename(fileBaseName, 50 - fileExt.length);
+    const sanitizedFileName = sanitizedBaseName + fileExt;
     
     const sourceFile = `${sanitizedCode}-${sanitizedSubType}-${sanitizedFileName}`;
     const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);

package/lib/helpers/mediaHelper.js

@@ -1,7 +1,7 @@
 const path = require('path');
 const fs = require('fs');
 const AWS = require('../config/awsConfig.js');
-const { sanitizeMediaFilename } = require('../utils/sanitizer.js');
+const { sanitizeMediaFilename } = require('../utils/inputSanitizer.js');
 const { logger } = require('../utils/logger');
 
 async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, contentType, messageType) {
@@ -10,13 +10,13 @@ async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, content
   const fileName = sanitizedTitle 
     ? `${messageType}/${messageID}_${sanitizedTitle}.${extension}`
     : `${messageType}/${messageID}.${extension}`;
-  logger.info(titleFile, messageType);
+  logger.info('[uploadMediaToS3] Media file prepared for upload', { fileName, messageType });
     
   try {
     await AWS.uploadBufferToS3(buffer, bucketName, fileName, contentType);
     return fileName;
   } catch (error) {
-    logger.error('Failed to upload media to S3:', error.stack);
+    logger.error('[uploadMediaToS3] Failed to upload media to S3:', error.stack);
     throw error;
   }
 }

package/lib/helpers/messageHelper.js

@@ -2,19 +2,31 @@ const moment = require('moment-timezone');
 const { Message } = require('../models/messageModel.js');
 const { logger } = require('../utils/logger');
 
-const updateMessageRecord = async (reply, thread) => {
+const updateMessageRecord = async (reply, thread, processedContent = null) => {
   const threadId = thread.getConversationId();
   
+  const updateData = { 
+    assistant_id: thread.getAssistantId(), 
+    thread_id: threadId,
+    processed: true 
+  };
+  
+  if (processedContent && reply.media) {
+    updateData.media = {
+      ...reply.media,
+      metadata: {
+        ...(reply.media.metadata || {}),
+        processed_content: processedContent
+      }
+    };
+  }
+  
   await Message.updateOne(
     { message_id: reply.message_id, timestamp: reply.timestamp },
-    { $set: { 
-      assistant_id: thread.getAssistantId(), 
-      thread_id: threadId,
-      processed: true 
-    } }
+    { $set: updateData }
   );
   
-  logger.info(`[updateMessageRecord] Record updated - ID: ${reply.message_id}, Thread: ${threadId}, Processed: true`);
+  logger.info(`[updateMessageRecord] Record updated - ID: ${reply.message_id}, Thread: ${threadId}, Processed: true, MediaContentUpdated: ${!!(processedContent && reply.media)}`);
 };
 
 
@@ -81,7 +93,12 @@ function formatMessage(reply) {
       .locale('es')
       .format('dddd, D [de] MMMM [de] YYYY [a las] h:mm A');
     
-    return `[${mexicoCityTime}] ${reply.body}`;
+    let messageContent = reply.body;
+    if (reply.media?.metadata?.processed_content) {
+      messageContent = reply.media.metadata.processed_content;
+    }
+    
+    return `[${mexicoCityTime}] ${messageContent}`;
   } catch (error) {
     logger.error(`[formatMessage] Error for message ID: ${reply.message_id}:`, error?.message || String(error));
     return null;

package/lib/helpers/messageStatusHelper.js

@@ -1,27 +1,28 @@
 const { Message } = require('../models/messageModel');
 const { logger } = require('../utils/logger');
+const { handle24HourWindowError } = require('./templateRecoveryHelper');
 
 /**
  * Update message delivery status in the database based on Twilio status callback data
  */
 async function updateMessageStatus(messageSid, status, errorCode = null, errorMessage = null) {
   try {
-    const statusInfo = {
-      status,
-      updatedAt: new Date()
+    const updateData = {
+      'statusInfo.status': status,
+      'statusInfo.updatedAt': new Date()
     };
 
     if (errorCode) {
-      statusInfo.errorCode = errorCode;
+      updateData['statusInfo.errorCode'] = errorCode;
     }
 
     if (errorMessage) {
-      statusInfo.errorMessage = errorMessage;
+      updateData['statusInfo.errorMessage'] = errorMessage;
     }
 
     const updated = await Message.findOneAndUpdate(
       { message_id: messageSid },
-      { $set: { statusInfo } },
+      { $set: updateData },
       { new: true }
     );
 
@@ -62,12 +63,20 @@ async function handleStatusCallback(twilioStatusData) {
     return null;
   }
 
-  return await updateMessageStatus(
+  const updated = await updateMessageStatus(
     MessageSid,
     MessageStatus.toLowerCase(),
     ErrorCode || null,
     ErrorMessage || null
   );
+
+  if ((ErrorCode === 63016 || ErrorCode === '63016') && updated) {
+    handle24HourWindowError(updated, MessageSid).catch(err => 
+      logger.error('[MessageStatus] Recovery error', { messageSid: MessageSid, error: err.message })
+    );
+  }
+
+  return updated;
 }
 
 /**
@@ -76,7 +85,7 @@ async function handleStatusCallback(twilioStatusData) {
 async function getMessageStatus(messageSid) {
   try {
     const message = await Message.findOne({ message_id: messageSid })
-      .select('statusInfo message_id numero body')
+      .select('statusInfo recoveryInfo message_id numero body')
       .lean();
 
     return message;

package/lib/helpers/processHelper.js

@@ -2,8 +2,7 @@ const fs = require('fs');
 const { generatePresignedUrl } = require('../config/awsConfig.js');
 const { analyzeImage } = require('./llmsHelper.js');
 const { cleanupFiles, downloadMediaAndCreateFile } = require('./filesHelper.js');
-const { formatMessage } = require('./messageHelper.js');
-const { sanitizeLogMetadata } = require('../utils/sanitizer.js');
+const { sanitizeLogMetadata } = require('../utils/inputSanitizer.js');
 const { withTracing } = require('../utils/tracingDecorator.js');
 
 /**
@@ -35,23 +34,19 @@ const logger = {
 
 /**
  * Dedicated message processing utilities
- * Handles text messages, media files, audio transcription, and thread operations
  */
 const processTextMessage = (reply) => {
-  const formattedMessage = formatMessage(reply);
   logger.info('processTextMessage', { 
     message_id: reply.message_id,
     timestamp: reply.timestamp,
     from_me: reply.from_me,
     body: reply.body,
-    hasContent: !!formattedMessage,
-    formattedMessage
+    hasContent: !!reply.body
   });
-  logger.debug('processTextMessage_content', { formattedMessage });
   
   const messagesChat = [];
-  if (formattedMessage) {
-    messagesChat.push({ type: 'text', text: formattedMessage });
+  if (reply.body) {
+    messagesChat.push({ type: 'text', text: reply.body });
   }
   
   return messagesChat;
@@ -121,8 +116,6 @@ const processImageFileCore = async (fileName, reply) => {
       ...timings
     });
     
-    logger.debug('processImageFile_analysis', { imageAnalysis });
-    
   } catch (error) {
     logger.error('processImageFile', error, {
       message_id: reply.message_id,

package/lib/helpers/qrHelper.js

@@ -12,12 +12,6 @@ async function generateQRBuffer(text) {
   }
 }
 
-function bufferToBase64(buffer) {
-  return buffer.toString('base64');
-}
-
-
 module.exports = {
-  generateQRBuffer,
-  bufferToBase64
+  generateQRBuffer
 };

package/lib/helpers/templateRecoveryHelper.js

@@ -0,0 +1,152 @@
+const { logger } = require('../utils/logger');
+const { getDefaultInstance } = require('../core/NexusMessaging');
+const { Template, configureNexusProvider: configureTemplateProvider } = require('../templates/templateStructure');
+const { sendMessage } = require('../core/NexusMessaging');
+const { Message } = require('../models/messageModel');
+
+/**
+ * Handle 24-hour window error by creating template and sending when approved
+ */
+async function handle24HourWindowError(message, messageSid) {
+  try {
+    if (!message?.body || !message?.numero) return;
+
+    const existingMessage = await Message.findOne({ message_id: messageSid })
+      .select('recoveryInfo')
+      .lean();
+    
+    if (existingMessage?.recoveryInfo?.status === 'in_progress') {
+      logger.info('[TemplateRecovery] Recovery already in progress', { messageSid });
+      return;
+    }
+
+    const messaging = getDefaultInstance();
+    const provider = messaging?.getProvider();
+    if (!provider?.createTemplate) return;
+
+    configureTemplateProvider(provider);
+
+    const templateName = `auto_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+    const template = new Template(templateName, 'UTILITY', 'es');
+    template.setBody(message.body, []);
+    const twilioContent = await template.save();
+
+    // Submit for approval
+    const approvalName = `${templateName}_${Date.now()}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+    await provider.submitForApproval(twilioContent.sid, approvalName, 'UTILITY');
+
+    await Message.updateOne(
+      { message_id: messageSid },
+      { 
+        $set: { 
+          'recoveryInfo.status': 'in_progress',
+          'recoveryInfo.templateSid': twilioContent.sid,
+          'recoveryInfo.startedAt': new Date()
+        } 
+      }
+    );
+
+    logger.info('[TemplateRecovery] Template created', { messageSid, templateSid: twilioContent.sid });
+
+    const checkApproval = async (attempt = 0, maxAttempts = 40) => {
+      if (attempt >= maxAttempts) {
+        await Message.updateOne(
+          { message_id: messageSid },
+          { 
+            $set: { 
+              'recoveryInfo.status': 'failed',
+              'recoveryInfo.completedAt': new Date(),
+              'recoveryInfo.error': 'Max attempts reached, template not approved yet'
+            } 
+          }
+        );
+        
+        logger.warn('[TemplateRecovery] Max attempts reached, template not approved yet', { messageSid, templateSid: twilioContent.sid });
+        return;
+      }
+
+      setTimeout(async () => {
+        try {
+          await Message.updateOne(
+            { message_id: messageSid },
+            { $set: { 'recoveryInfo.lastCheckedAt': new Date() } }
+          );
+
+          const status = await provider.checkApprovalStatus(twilioContent.sid);
+          const approvalStatus = status?.approvalRequest?.status?.toUpperCase();
+
+          if (approvalStatus === 'APPROVED') {
+            await sendMessage({ code: message.numero, contentSid: twilioContent.sid, variables: {} });
+            
+            await Message.updateOne(
+              { message_id: messageSid },
+              { 
+                $set: { 
+                  'recoveryInfo.status': 'completed',
+                  'recoveryInfo.completedAt': new Date()
+                } 
+              }
+            );
+            
+            logger.info('[TemplateRecovery] Template sent', { messageSid, templateSid: twilioContent.sid });
+          } else if (approvalStatus === 'REJECTED') {
+            await Message.updateOne(
+              { message_id: messageSid },
+              { 
+                $set: { 
+                  'recoveryInfo.status': 'failed',
+                  'recoveryInfo.completedAt': new Date(),
+                  'recoveryInfo.error': 'Template rejected by Twilio'
+                } 
+              }
+            );
+            
+            logger.warn('[TemplateRecovery] Template rejected', { messageSid, templateSid: twilioContent.sid });
+          } else {
+            checkApproval(attempt + 1, maxAttempts);
+          }
+        } catch (err) {
+          logger.error('[TemplateRecovery] Error checking approval', { error: err.message, attempt });
+          
+          await Message.updateOne(
+            { message_id: messageSid },
+            { $set: { 'recoveryInfo.error': err.message } }
+          );
+          
+          if (attempt + 1 < maxAttempts) {
+            checkApproval(attempt + 1, maxAttempts);
+          } else {
+            await Message.updateOne(
+              { message_id: messageSid },
+              { 
+                $set: { 
+                  'recoveryInfo.status': 'failed',
+                  'recoveryInfo.completedAt': new Date(),
+                  'recoveryInfo.error': `Max attempts reached: ${err.message}`
+                } 
+              }
+            );
+          }
+        }
+      }, 15 * 60 * 1000);
+    };
+
+    checkApproval(0);
+
+  } catch (error) {
+    await Message.updateOne(
+      { message_id: messageSid },
+      { 
+        $set: { 
+          'recoveryInfo.status': 'failed',
+          'recoveryInfo.completedAt': new Date(),
+          'recoveryInfo.error': error.message
+        } 
+      }
+    ).catch(err => logger.error('[TemplateRecovery] Failed to update error status', { error: err.message }));
+    
+    logger.error('[TemplateRecovery] Error', { messageSid, error: error.message });
+  }
+}
+
+module.exports = { handle24HourWindowError };