@lengelhard/imap-email-mcp 1.2.0 → 1.3.0

package/index.js

@@ -461,11 +461,44 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ['uid', 'seen']
         }
+      },
+      {
+        name: 'move_thread',
+        description: 'Move an entire email thread (all messages matching a subject) from one folder to another in a single call. Strips Re:/Fwd: prefixes for matching. Use move_email for single-message precision moves.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            subject: {
+              type: 'string',
+              description: 'Subject line of the thread to move. Re:/Fwd: prefixes are stripped automatically for matching.'
+            },
+            from_folder: {
+              type: 'string',
+              description: 'Source folder to search for thread messages'
+            },
+            to_folder: {
+              type: 'string',
+              description: 'Destination folder to move messages into'
+            },
+            from_address: {
+              type: 'string',
+              description: 'Optional sender address to disambiguate threads with generic subjects'
+            }
+          },
+          required: ['subject', 'from_folder', 'to_folder']
+        }
       }
     ]
   };
 });
 
+// Strip Re:/Fwd:/Fw: prefixes from a subject line for thread matching.
+// Handles nested prefixes like "Re: Re: Fwd: topic" → "topic"
+function normalizeSubject(subject) {
+  if (!subject) return '';
+  return subject.replace(/^(\s*(Re|Fwd|Fw)\s*:\s*)+/i, '').trim();
+}
+
 // Helper function to connect to IMAP
 async function connectIMAP() {
   if (!IMAP_CONFIG.imap.password) {
@@ -853,15 +886,75 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           bcc: args.bcc
         };
 
+        // Send via SMTP and capture the raw RFC 5322 message
         const info = await transporter.sendMail(mailOptions);
 
+        // Build RFC 5322 message string to APPEND to Sent folder via IMAP
+        // Use the same content that was sent so the Sent copy is identical
+        const sentDate = new Date();
+        const boundary = `----=_Part_${Date.now()}`;
+        let rawMessage = '';
+        rawMessage += `From: ${SMTP_CONFIG.auth.user}\r\n`;
+        rawMessage += `To: ${args.to}\r\n`;
+        if (args.cc) rawMessage += `Cc: ${args.cc}\r\n`;
+        if (args.bcc) rawMessage += `Bcc: ${args.bcc}\r\n`;
+        rawMessage += `Subject: ${args.subject}\r\n`;
+        rawMessage += `Date: ${sentDate.toUTCString()}\r\n`;
+        rawMessage += `Message-ID: ${info.messageId}\r\n`;
+        rawMessage += `MIME-Version: 1.0\r\n`;
+
+        if (args.html) {
+          rawMessage += `Content-Type: multipart/alternative; boundary="${boundary}"\r\n\r\n`;
+          rawMessage += `--${boundary}\r\n`;
+          rawMessage += `Content-Type: text/plain; charset=utf-8\r\n\r\n`;
+          rawMessage += `${args.body || ''}\r\n`;
+          rawMessage += `--${boundary}\r\n`;
+          rawMessage += `Content-Type: text/html; charset=utf-8\r\n\r\n`;
+          rawMessage += `${args.html}\r\n`;
+          rawMessage += `--${boundary}--\r\n`;
+        } else {
+          rawMessage += `Content-Type: text/plain; charset=utf-8\r\n\r\n`;
+          rawMessage += `${args.body || ''}\r\n`;
+        }
+
+        // APPEND to Sent folder via IMAP
+        let sentFolderResult = 'skipped';
+        try {
+          const connection = await connectIMAP();
+          try {
+            // Try common Sent folder names in order
+            const sentFolderCandidates = ['Sent', 'INBOX.Sent', 'Sent Items', 'Sent Mail', '[Gmail]/Sent Mail'];
+            let sentFolder = 'Sent'; // default fallback
+
+            const folders = await connection.getBoxes();
+            const flatFolders = Object.keys(folders);
+            for (const candidate of sentFolderCandidates) {
+              if (flatFolders.some(f => f.toLowerCase() === candidate.toLowerCase())) {
+                sentFolder = candidate;
+                break;
+              }
+            }
+
+            await connection.append(rawMessage, {
+              mailbox: sentFolder,
+              flags: ['\\Seen']
+            });
+            sentFolderResult = `saved to ${sentFolder}`;
+          } finally {
+            connection.end();
+          }
+        } catch (appendErr) {
+          sentFolderResult = `failed: ${appendErr.message}`;
+        }
+
         return {
           content: [{
             type: 'text',
             text: JSON.stringify({
               success: true,
               messageId: info.messageId,
-              response: info.response
+              response: info.response,
+              sentFolder: sentFolderResult
             }, null, 2)
           }]
         };
@@ -1048,6 +1141,115 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
+      case 'move_thread': {
+        const { subject, from_folder, to_folder, from_address } = args;
+        const normalizedTarget = normalizeSubject(subject);
+
+        if (!normalizedTarget) {
+          return {
+            content: [{ type: 'text', text: 'Error: subject cannot be empty' }],
+            isError: true
+          };
+        }
+
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(from_folder);
+
+          // Build IMAP search criteria: match subject header (and optionally sender)
+          const searchCriteria = [['SUBJECT', normalizedTarget]];
+          if (from_address) {
+            searchCriteria.push(['FROM', from_address]);
+          }
+
+          const fetchOptions = {
+            bodies: ['HEADER.FIELDS (SUBJECT FROM)'],
+            struct: false
+          };
+
+          const messages = await connection.search(searchCriteria, fetchOptions);
+
+          if (messages.length === 0) {
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  success: false,
+                  moved: 0,
+                  failed: 0,
+                  from_folder,
+                  to_folder,
+                  message: `No messages found matching subject "${normalizedTarget}" in ${from_folder}`
+                }, null, 2)
+              }]
+            };
+          }
+
+          // IMAP SUBJECT search is a substring match, so post-filter to ensure
+          // each message's normalized subject matches the target exactly.
+          const matchingUIDs = [];
+          for (const msg of messages) {
+            const header = msg.parts.find(p => p.which.includes('HEADER'))?.body || {};
+            const msgSubject = normalizeSubject((header.subject || [])[0] || '');
+            if (msgSubject.toLowerCase() === normalizedTarget.toLowerCase()) {
+              matchingUIDs.push(msg.attributes.uid);
+            }
+          }
+
+          if (matchingUIDs.length === 0) {
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  success: false,
+                  moved: 0,
+                  failed: 0,
+                  from_folder,
+                  to_folder,
+                  message: `IMAP returned results but none matched the exact subject "${normalizedTarget}" after normalization`
+                }, null, 2)
+              }]
+            };
+          }
+
+          // Move each matching UID using the same imap.move() pattern as move_email
+          let moved = 0;
+          const failures = [];
+          for (const uid of matchingUIDs) {
+            try {
+              await new Promise((resolve, reject) => {
+                connection.imap.move(uid, to_folder, (err) => {
+                  if (err) reject(err);
+                  else resolve();
+                });
+              });
+              moved++;
+            } catch (moveErr) {
+              failures.push({ uid, error: moveErr.message });
+            }
+          }
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: failures.length === 0,
+                moved,
+                failed: failures.length,
+                total_found: matchingUIDs.length,
+                from_folder,
+                to_folder,
+                subject: normalizedTarget,
+                ...(failures.length > 0 && { failures })
+              }, null, 2)
+            }]
+          };
+        } finally {
+          connection.end();
+        }
+      }
+
       default:
         return { content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lengelhard/imap-email-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "MCP server for Claude Code that provides email capabilities through IMAP/SMTP. Read, search, compose, and manage emails from any IMAP provider.",
   "type": "module",
   "main": "index.js",