@lengelhard/imap-email-mcp 1.0.4 → 1.1.0

package/index.js

@@ -347,9 +347,28 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ['to', 'subject']
         }
       },
+      {
+        name: 'delete_email',
+        description: 'Delete an email by UID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Email UID to delete'
+            },
+            folder: {
+              type: 'string',
+              description: 'Folder name (default: INBOX)',
+              default: 'INBOX'
+            }
+          },
+          required: ['uid']
+        }
+      },
       {
         name: 'move_email',
-        description: 'Move an email from one folder to another (e.g. INBOX to Archive)',
+        description: 'Move an email from one folder to another (e.g. Inbox → Action, Waiting, Delegated, Hold)',
         inputSchema: {
           type: 'object',
           properties: {
@@ -359,35 +378,61 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             from_folder: {
               type: 'string',
-              description: 'Source folder (default: INBOX)',
+              description: 'Source folder name (default: INBOX)',
               default: 'INBOX'
             },
             to_folder: {
               type: 'string',
-              description: 'Destination folder (e.g. Archive, Sent, Trash)',
-              default: 'Archive'
+              description: 'Destination folder name (e.g. Action, Waiting, Delegated, Hold, Archive)'
             }
           },
-          required: ['uid']
+          required: ['uid', 'to_folder']
         }
       },
       {
-        name: 'delete_email',
-        description: 'Delete an email by UID',
+        name: 'flag_email',
+        description: 'Add or remove the \\Flagged flag on an email (star/unstar). Used to manage the /Flagged urgency overlay.',
         inputSchema: {
           type: 'object',
           properties: {
             uid: {
               type: 'number',
-              description: 'Email UID to delete'
+              description: 'Email UID'
             },
             folder: {
               type: 'string',
-              description: 'Folder name (default: INBOX)',
+              description: 'Folder containing the email (default: INBOX)',
+              default: 'INBOX'
+            },
+            flagged: {
+              type: 'boolean',
+              description: 'true to add the flag (star), false to remove it (unstar)'
+            }
+          },
+          required: ['uid', 'flagged']
+        }
+      },
+      {
+        name: 'mark_seen',
+        description: 'Mark an email as read (seen) or unread (unseen). Used to signal triage state via the \\Seen flag.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Email UID'
+            },
+            folder: {
+              type: 'string',
+              description: 'Folder containing the email (default: INBOX)',
               default: 'INBOX'
+            },
+            seen: {
+              type: 'boolean',
+              description: 'true to mark as read, false to mark as unread'
             }
           },
-          required: ['uid']
+          required: ['uid', 'seen']
         }
       }
     ]
@@ -781,47 +826,149 @@ 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)
           }]
         };
       }
 
+      case 'delete_email': {
+        const folder = args.folder || 'INBOX';
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+          await connection.addFlags(args.uid, ['\\Deleted']);
+          await connection.closeBox(true); // Expunge
+
+          return { content: [{ type: 'text', text: 'Email deleted successfully' }] };
+        } finally {
+          connection.end();
+        }
+      }
+
       case 'move_email': {
         const fromFolder = args.from_folder || 'INBOX';
-        const toFolder = args.to_folder || 'Archive';
+        const toFolder = args.to_folder;
         const connection = await connectIMAP();
 
         try {
           await connection.openBox(fromFolder);
 
-          // imap-simple exposes the underlying imap connection via ._imap
-          // Use it to copy the message then delete the original
+          // node-imap exposes move() on the underlying imap object.
+          // We wrap it in a Promise so it fits the async/await flow.
           await new Promise((resolve, reject) => {
-            connection.imap.copy(args.uid, toFolder, (err) => {
+            connection.imap.move(args.uid, toFolder, (err) => {
               if (err) reject(err);
               else resolve();
             });
           });
 
-          // Mark original as deleted and expunge
-          await connection.addFlags(args.uid, ['\\Deleted']);
-          await connection.closeBox(true); // true = expunge on close
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                uid: args.uid,
+                from: fromFolder,
+                to: toFolder
+              }, null, 2)
+            }]
+          };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'flag_email': {
+        const folder = args.folder || 'INBOX';
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+
+          if (args.flagged) {
+            await connection.addFlags(args.uid, ['\\Flagged']);
+          } else {
+            await connection.delFlags(args.uid, ['\\Flagged']);
+          }
 
           return {
             content: [{
               type: 'text',
               text: JSON.stringify({
                 success: true,
-                message: `Email ${args.uid} moved from ${fromFolder} to ${toFolder}`
+                uid: args.uid,
+                folder,
+                flagged: args.flagged
               }, null, 2)
             }]
           };
@@ -830,16 +977,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
-      case 'delete_email': {
+      case 'mark_seen': {
         const folder = args.folder || 'INBOX';
         const connection = await connectIMAP();
 
         try {
           await connection.openBox(folder);
-          await connection.addFlags(args.uid, ['\\Deleted']);
-          await connection.closeBox(true); // Expunge
 
-          return { content: [{ type: 'text', text: 'Email deleted successfully' }] };
+          if (args.seen) {
+            await connection.addFlags(args.uid, ['\\Seen']);
+          } else {
+            await connection.delFlags(args.uid, ['\\Seen']);
+          }
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                uid: args.uid,
+                folder,
+                seen: args.seen
+              }, null, 2)
+            }]
+          };
         } finally {
           connection.end();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lengelhard/imap-email-mcp",
-  "version": "1.0.4",
+  "version": "1.1.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",