@lengelhard/imap-email-mcp 1.0.5 → 1.2.0

package/index.js

@@ -83,7 +83,7 @@ function findAttachmentParts(struct, parts = []) {
       );
 
     if (isAttachment) {
-      parts.push({ node, filename, contentType, disposition });
+      parts.push({ node, filename, contentType, disposition, partID: node.partID });
     }
   }
 
@@ -347,6 +347,33 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ['to', 'subject']
         }
       },
+      {
+        name: 'download_attachment',
+        description: 'Download a specific email attachment as base64-encoded content. Use the partID from get_email response.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Email UID'
+            },
+            part_id: {
+              type: 'string',
+              description: 'MIME part ID of the attachment (from get_email response)'
+            },
+            filename: {
+              type: 'string',
+              description: 'Filename of the attachment (used as fallback to find part_id if not provided)'
+            },
+            folder: {
+              type: 'string',
+              description: 'Folder name (default: INBOX)',
+              default: 'INBOX'
+            }
+          },
+          required: ['uid']
+        }
+      },
       {
         name: 'delete_email',
         description: 'Delete an email by UID',
@@ -365,6 +392,75 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ['uid']
         }
+      },
+      {
+        name: 'move_email',
+        description: 'Move an email from one folder to another (e.g. Inbox → Action, Waiting, Delegated, Hold)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            uid: {
+              type: 'number',
+              description: 'Email UID to move'
+            },
+            from_folder: {
+              type: 'string',
+              description: 'Source folder name (default: INBOX)',
+              default: 'INBOX'
+            },
+            to_folder: {
+              type: 'string',
+              description: 'Destination folder name (e.g. Action, Waiting, Delegated, Hold, Archive)'
+            }
+          },
+          required: ['uid', 'to_folder']
+        }
+      },
+      {
+        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'
+            },
+            folder: {
+              type: 'string',
+              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', 'seen']
+        }
       }
     ]
   };
@@ -757,80 +853,97 @@ 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,
-              sentFolder: sentFolderResult
+              response: info.response
             }, null, 2)
           }]
         };
       }
 
+      case 'download_attachment': {
+        const folder = args.folder || 'INBOX';
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+
+          // Fetch struct to locate the part
+          const structFetch = await connection.search([['UID', args.uid]], {
+            bodies: [],
+            struct: true
+          });
+
+          if (structFetch.length === 0) {
+            return { content: [{ type: 'text', text: 'Email not found' }] };
+          }
+
+          const msg = structFetch[0];
+          let partID = args.part_id;
+
+          // If no partID given, find it by filename
+          if (!partID && args.filename) {
+            const attachmentParts = findAttachmentParts(msg.attributes.struct || []);
+            const match = attachmentParts.find(p =>
+              (p.filename || '').toLowerCase() === args.filename.toLowerCase()
+            );
+            if (match) partID = match.partID;
+          }
+
+          if (!partID) {
+            return {
+              content: [{ type: 'text', text: 'Could not determine part ID. Please provide part_id from get_email response.' }],
+              isError: true
+            };
+          }
+
+          // Fetch the specific MIME part
+          const partFetch = await connection.search([['UID', args.uid]], {
+            bodies: [partID],
+            struct: true
+          });
+
+          if (partFetch.length === 0) {
+            return { content: [{ type: 'text', text: 'Attachment part not found' }] };
+          }
+
+          const partData = partFetch[0].parts.find(p => p.which === partID);
+
+          if (!partData) {
+            return { content: [{ type: 'text', text: `Part ${partID} not found in message` }] };
+          }
+
+          // imap-simple returns the body already base64-encoded by the mail server.
+          // Re-encoding would corrupt the output — strip whitespace and return directly.
+          const base64Content = String(partData.body).replace(/\s+/g, '');
+
+          const attachmentParts = findAttachmentParts(msg.attributes.struct || []);
+          const attachmentInfo = attachmentParts.find(p => p.partID === partID);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                uid: args.uid,
+                partID,
+                filename: attachmentInfo?.filename || args.filename || 'attachment',
+                contentType: attachmentInfo?.contentType || 'application/octet-stream',
+                encoding: 'base64',
+                data: base64Content
+              }, null, 2)
+            }]
+          };
+        } finally {
+          connection.end();
+        }
+      }
+
       case 'delete_email': {
         const folder = args.folder || 'INBOX';
         const connection = await connectIMAP();
@@ -846,6 +959,95 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
+      case 'move_email': {
+        const fromFolder = args.from_folder || 'INBOX';
+        const toFolder = args.to_folder;
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(fromFolder);
+
+          await new Promise((resolve, reject) => {
+            connection.imap.move(args.uid, toFolder, (err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+          });
+
+          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,
+                uid: args.uid,
+                folder,
+                flagged: args.flagged
+              }, null, 2)
+            }]
+          };
+        } finally {
+          connection.end();
+        }
+      }
+
+      case 'mark_seen': {
+        const folder = args.folder || 'INBOX';
+        const connection = await connectIMAP();
+
+        try {
+          await connection.openBox(folder);
+
+          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();
+        }
+      }
+
       default:
         return { content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
     }

package/package.json

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