@peopl-health/nexus 2.5.8 → 2.5.10

package/lib/adapters/TwilioProvider.js

@@ -105,15 +105,52 @@ class TwilioProvider extends MessageProvider {
       }
     }
 
-    // Validate message has content
     if (!messageParams.body && !messageParams.mediaUrl && !messageParams.contentSid) {
       throw new Error('Message must have body, media URL, or content SID');
     }
 
-    logger.info('[TwilioProvider] Sending message', messageParams);
-
-    try {
-      const result = await this.twilioClient.messages.create(messageParams);
+    let result;
+    const chunks = messageParams.body && messageParams.body.length > 1600 && !messageParams.mediaUrl && !messageParams.contentSid
+      ? this.splitMessageAtWordBoundaries(messageParams.body)
+      : null;
+    
+    if (chunks) {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunkParams = { ...messageParams, body: chunks[i] };
+        result = await this.twilioClient.messages.create(chunkParams);
+        if (this.messageStorage && typeof this.messageStorage.saveMessage === 'function') {
+          try {
+            await this.messageStorage.saveMessage({
+              ...messageData,
+              body: chunks[i],
+              code: formattedCode,
+              from: formattedFrom,
+              messageId: result.sid,
+              provider: 'twilio',
+              timestamp: new Date(),
+              fromMe: true,
+              processed: messageData.processed !== undefined ? messageData.processed : false,
+              statusInfo: {
+                status: result.status ? result.status.toLowerCase() : null,
+                updatedAt: result.dateCreated || new Date()
+              }
+            });
+            logger.info('[TwilioProvider] Message chunk persisted', { messageId: result.sid, chunk: i + 1, total: chunks.length });
+          } catch (storageError) {
+            logger.error('TwilioProvider storage failed:', storageError);
+          }
+        }
+        if (i < chunks.length - 1) {
+          await new Promise(resolve => setTimeout(resolve, 100));
+        }
+      }
+    } else {
+      logger.info('[TwilioProvider] Sending message', messageParams);
+      try {
+        result = await this.twilioClient.messages.create(messageParams);
+      } catch (error) {
+        throw new Error(`Twilio send failed: ${error.message}`);
+      }
       if (this.messageStorage && typeof this.messageStorage.saveMessage === 'function') {
         try {
           await this.messageStorage.saveMessage({
@@ -135,17 +172,15 @@ class TwilioProvider extends MessageProvider {
           logger.error('TwilioProvider storage failed:', storageError);
         }
       }
-      
-      return {
-        success: true,
-        messageId: result.sid,
-        provider: 'twilio',
-        status: result.status,
-        result
-      };
-    } catch (error) {
-      throw new Error(`Twilio send failed: ${error.message}`);
     }
+    
+    return {
+      success: true,
+      messageId: result.sid,
+      provider: 'twilio',
+      status: result.status,
+      result
+    };
   }
 
   async sendTypingIndicator(messageId) {
@@ -394,6 +429,46 @@ class TwilioProvider extends MessageProvider {
     return Math.max(0, targetTime.getTime() - now.getTime());
   }
 
+  /**
+   * Split a message into chunks at sentence boundaries, respecting Twilio's character limit
+   * @param {string} text - The message text to split
+   * @param {number} maxLength - Maximum length per chunk (default: 1600)
+   * @returns {Array<string>} Array of message chunks
+   */
+  splitMessageAtWordBoundaries(text, maxLength = 1600) {
+    if (!text || text.length <= maxLength) return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > maxLength) {
+      let splitIndex = -1;
+      const searchStart = Math.max(0, maxLength - 500); // Look back up to 500 chars
+      const searchArea = remaining.substring(searchStart, maxLength + 1);
+      
+      const regex = /[.!?]\s/g;
+      let match;
+      let lastMatchIndex = -1;
+      
+      while ((match = regex.exec(searchArea)) !== null) {
+        const absoluteIndex = searchStart + match.index;
+        if (absoluteIndex <= maxLength) {
+          lastMatchIndex = absoluteIndex + match[0].length;
+        }
+      }
+      
+      if (lastMatchIndex > 0) {
+        splitIndex = lastMatchIndex;
+      } else {
+        splitIndex = remaining.lastIndexOf(' ', maxLength);
+      }
+      
+      const chunk = remaining.substring(0, splitIndex === -1 ? maxLength : splitIndex).trim();
+      if (chunk) chunks.push(chunk);
+      remaining = remaining.substring(splitIndex === -1 ? maxLength : splitIndex).trim();
+    }
+    if (remaining) chunks.push(remaining);
+    return chunks;
+  }
+
   /**
    * List templates from Twilio Content API
    * @param {Object} options - Query options

package/lib/controllers/threadController.js

@@ -0,0 +1,151 @@
+const { Thread } = require('../models/threadModel');
+const { logger } = require('../utils/logger');
+
+/**
+ * Update review status for a specific thread by code
+ */
+const updateThreadReviewStatus = async (req, res) => {
+  try {
+    const { code } = req.params;
+    const { review } = req.body;
+
+    if (typeof review !== 'boolean') {
+      return res.status(400).json({
+        success: false,
+        message: 'Review status must be a boolean value'
+      });
+    }
+
+    const thread = await Thread.findOneAndUpdate(
+      { code },
+      { review },
+      { new: true }
+    );
+
+    if (!thread) {
+      return res.status(404).json({
+        success: false,
+        message: 'Thread not found'
+      });
+    }
+
+    logger.info('[updateThreadReviewStatus] Thread review status updated', { 
+      code: code.substring(0, 3) + '***' + code.slice(-4), 
+      review 
+    });
+
+    res.json({
+      success: true,
+      message: 'Thread review status updated successfully',
+      thread: {
+        code: thread.code,
+        review: thread.review,
+        updatedAt: thread.updatedAt
+      }
+    });
+  } catch (error) {
+    logger.error('[updateThreadReviewStatus] Error updating thread review status', { error });
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error'
+    });
+  }
+};
+
+/**
+ * Update review status for all threads at once
+ */
+const updateAllThreadsReviewStatus = async (req, res) => {
+  try {
+    const { review } = req.body;
+
+    if (typeof review !== 'boolean') {
+      return res.status(400).json({
+        success: false,
+        message: 'Review status must be a boolean value'
+      });
+    }
+
+    const result = await Thread.updateMany(
+      {},
+      { review }
+    );
+
+    logger.info('[updateAllThreadsReviewStatus] All threads review status updated', { 
+      review, 
+      modifiedCount: result.modifiedCount 
+    });
+
+    res.json({
+      success: true,
+      message: `Successfully updated review status for ${result.modifiedCount} threads`,
+      modifiedCount: result.modifiedCount,
+      review
+    });
+  } catch (error) {
+    logger.error('[updateAllThreadsReviewStatus] Error updating all threads review status', { error });
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error'
+    });
+  }
+};
+
+/**
+ * Get threads by review status
+ */
+const getThreadsByReviewStatus = async (req, res) => {
+  try {
+    const { review } = req.query;
+    const { page = 1, limit = 20 } = req.query;
+
+    const filter = {};
+    if (review !== undefined) {
+      filter.review = review === 'true';
+    }
+
+    const skip = (parseInt(page) - 1) * parseInt(limit);
+    
+    const threads = await Thread.find(filter)
+      .select('code review active stopped createdAt updatedAt')
+      .sort({ updatedAt: -1 })
+      .skip(skip)
+      .limit(parseInt(limit));
+
+    const total = await Thread.countDocuments(filter);
+
+    logger.info('[getThreadsByReviewStatus] Retrieved threads by review status', { 
+      filter, 
+      count: threads.length, 
+      total,
+      page: parseInt(page),
+      limit: parseInt(limit)
+    });
+
+    res.json({
+      success: true,
+      threads: threads.map(thread => ({
+        ...thread.toObject(),
+        code: thread.code.substring(0, 3) + '***' + thread.code.slice(-4)
+      })),
+      pagination: {
+        page: parseInt(page),
+        limit: parseInt(limit),
+        total,
+        totalPages: Math.ceil(total / parseInt(limit))
+      }
+    });
+  } catch (error) {
+    logger.error('[getThreadsByReviewStatus] Error retrieving threads by review status', { error });
+    res.status(500).json({
+      success: false,
+      message: 'Internal server error'
+    });
+  }
+};
+
+module.exports = {
+  updateThreadReviewStatus,
+  updateAllThreadsReviewStatus,
+  getThreadsByReviewStatus
+};

package/lib/core/NexusMessaging.js

@@ -1,5 +1,6 @@
 const { airtable, getBase } = require('../config/airtableConfig');
 const { Message } = require('../models/messageModel');
+const { Thread } = require('../models/threadModel');
 const { addMsgAssistant, replyAssistant } = require('../services/assistantService');
 const { createProvider } = require('../adapters/registry');
 const runtimeConfig = require('../config/runtimeConfig');
@@ -358,6 +359,19 @@ class NexusMessaging {
     // Ensure thread exists in background for new numbers
     if (chatId) {
       ensureThreadExists(chatId);
+      
+      // Reset review status to false when new message arrives
+      try {
+        await Thread.updateOne(
+          { code: chatId },
+          { review: false }
+        );
+      } catch (error) {
+        logger.error('[processIncomingMessage] Failed to reset thread review status', { 
+          code: chatId.substring(0, 3) + '***' + chatId.slice(-4), 
+          error 
+        });
+      }
     }
 
     if (chatId && hasPreprocessingHandler()) {

package/lib/models/threadModel.js

@@ -11,6 +11,7 @@ const threadSchema = new mongoose.Schema({
   nombre: { type: String, default: null },
   active: { type: Boolean, default: true },
   stopped: { type: Boolean, default: false },
+  review: { type: Boolean, default: false },
   nextSid: { type: [String], default: [] }
 }, { timestamps: true });
 

package/lib/routes/index.js

@@ -66,6 +66,12 @@ const templateRouteDefinitions = {
   'DELETE /:id': 'deleteTemplate'
 };
 
+const threadRouteDefinitions = {
+  'PUT /review/:code': 'updateThreadReviewStatus',
+  'PUT /review/all': 'updateAllThreadsReviewStatus',
+  'GET /review': 'getThreadsByReviewStatus'
+};
+
 // Helper function to create Express router from route definitions
 const createRouter = (routeDefinitions, controllers) => {
   const router = express.Router();
@@ -93,6 +99,7 @@ const patientController = require('../controllers/patientController');
 const qualityMessageController = require('../controllers/qualityMessageController');
 const templateController = require('../controllers/templateController');
 const templateFlowController = require('../controllers/templateFlowController');
+const threadController = require('../controllers/threadController');
 const uploadController = require('../controllers/uploadController');
 
 // Built-in controllers mapping
@@ -152,7 +159,12 @@ const builtInControllers = {
   deleteFlow: templateFlowController.deleteFlow,
   submitForApproval: templateController.submitForApproval,
   checkApprovalStatus: templateController.checkApprovalStatus,
-  deleteTemplate: templateController.deleteTemplate
+  deleteTemplate: templateController.deleteTemplate,
+  
+  // Thread controllers
+  updateThreadReviewStatus: threadController.updateThreadReviewStatus,
+  updateAllThreadsReviewStatus: threadController.updateAllThreadsReviewStatus,
+  getThreadsByReviewStatus: threadController.getThreadsByReviewStatus
 };
 
 // Helper function to setup all default routes using built-in controllers
@@ -164,6 +176,7 @@ const setupDefaultRoutes = (app) => {
   app.use('/api/message', createRouter(messageRouteDefinitions, builtInControllers));
   app.use('/api/patient', createRouter(patientRouteDefinitions, builtInControllers));
   app.use('/api/template', createRouter(templateRouteDefinitions, builtInControllers));
+  app.use('/api/thread', createRouter(threadRouteDefinitions, builtInControllers));
 };
 
 module.exports = {
@@ -175,6 +188,7 @@ module.exports = {
   messageRoutes: messageRouteDefinitions,
   patientRoutes: patientRouteDefinitions,
   templateRoutes: templateRouteDefinitions,
+  threadRoutes: threadRouteDefinitions,
   
   // Helper functions
   createRouter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.5.8",
+  "version": "2.5.10",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",