ms365-mcp-server 1.1.9 → 1.1.10

package/README.md

@@ -308,6 +308,95 @@ Files are:
 ### Cleanup
 Attachments are automatically cleaned up after 24 hours. You can also manually delete files from the `public/attachments` directory.
 
+### Enhanced Draft Email Operations
+```javascript
+// Create a basic draft
+{
+  "tool": "manage_email",
+  "arguments": {
+    "action": "draft",
+    "draftTo": ["colleague@company.com"],
+    "draftSubject": "Project Update",
+    "draftBody": "Draft content here...",
+    "draftBodyType": "text"
+  }
+}
+
+// Create a threaded reply draft (automatically appears in email thread)
+{
+  "tool": "manage_email",
+  "arguments": {
+    "action": "reply_draft",
+    "originalMessageId": "original_email_id",
+    "draftBody": "My reply content...",  // Optional comment
+    "replyToAll": false
+  }
+}
+
+// Create a forward draft (automatically includes original content)
+{
+  "tool": "manage_email",
+  "arguments": {
+    "action": "forward_draft", 
+    "originalMessageId": "original_email_id",
+    "draftBody": "Forwarding this for your review..."  // Optional comment
+  }
+}
+
+// Update an existing draft
+{
+  "tool": "manage_email",
+  "arguments": {
+    "action": "update_draft",
+    "draftId": "draft_email_id",
+    "draftSubject": "Updated Subject",
+    "draftBody": "Updated content..."
+  }
+}
+
+// Send a saved draft
+{
+  "tool": "manage_email",
+  "arguments": {
+    "action": "send_draft",
+    "draftId": "draft_email_id"
+  }
+}
+
+// List all draft emails
+{
+  "tool": "manage_email",
+  "arguments": {
+    "action": "list_drafts",
+    "maxResults": 20
+  }
+}
+```
+
+### Folder Operations
+```javascript
+// List all folders including subfolders with hierarchy
+{
+  "tool": "list_folders"
+}
+
+// List only child folders of a specific parent folder
+{
+  "tool": "list_folders",
+  "arguments": {
+    "parentFolderId": "inbox_folder_id"
+  }
+}
+
+// Search for folders by name (case-insensitive)
+{
+  "tool": "list_folders",
+  "arguments": {
+    "searchName": "projects"
+  }
+}
+```
+
 ## 🎯 Command Line Options
 
 ```bash

package/dist/index.js

@@ -67,7 +67,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.9"
+    version: "1.1.10"
 }, {
     capabilities: {
         resources: {
@@ -195,8 +195,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     action: {
                         type: "string",
-                        enum: ["read", "search", "list", "mark", "move", "delete", "search_to_me", "draft"],
-                        description: "Action to perform: read (get email by ID), search (find emails), list (folder contents), mark (read/unread), move (to folder), delete (permanently), search_to_me (emails addressed to you), draft (create/save draft)"
+                        enum: ["read", "search", "list", "mark", "move", "delete", "search_to_me", "draft", "update_draft", "send_draft", "list_drafts", "reply_draft", "forward_draft"],
+                        description: "Action to perform: read (get email by ID), search (find emails), list (folder contents), mark (read/unread), move (to folder), delete (permanently), search_to_me (emails addressed to you), draft (create/save draft), update_draft (modify existing draft), send_draft (send saved draft), list_drafts (list draft emails), reply_draft (create reply draft), forward_draft (create forward draft)"
                     },
                     messageId: {
                         type: "string",
@@ -329,6 +329,24 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             required: ["name", "contentBytes"]
                         },
                         description: "List of email attachments for draft (optional)"
+                    },
+                    // Additional draft parameters
+                    draftId: {
+                        type: "string",
+                        description: "Draft email ID (required for update_draft and send_draft actions)"
+                    },
+                    originalMessageId: {
+                        type: "string",
+                        description: "Original message ID for reply_draft and forward_draft actions"
+                    },
+                    replyToAll: {
+                        type: "boolean",
+                        description: "Reply to all recipients (used with reply_draft action)",
+                        default: false
+                    },
+                    conversationId: {
+                        type: "string",
+                        description: "Conversation ID for threading drafts (optional)"
                     }
                 },
                 required: ["action"],
@@ -360,13 +378,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: "list_folders",
-            description: "List all mail folders in the mailbox. Returns folder names, IDs, and item counts for navigation and organization.",
+            description: "List all mail folders in the mailbox including subfolders. Returns folder hierarchy with names, IDs, paths, and item counts for navigation and organization. Now includes child folders inside parent folders like Inbox subfolders.",
             inputSchema: {
                 type: "object",
                 properties: {
                     userId: {
                         type: "string",
                         description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    parentFolderId: {
+                        type: "string",
+                        description: "Optional: List only child folders of this parent folder ID. If not specified, returns complete folder hierarchy."
+                    },
+                    searchName: {
+                        type: "string",
+                        description: "Optional: Search for folders by name (case-insensitive partial match)"
                     }
                 },
                 additionalProperties: false
@@ -822,7 +848,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             body: args.draftBody,
                             bodyType: args.draftBodyType || 'text',
                             importance: args.draftImportance || 'normal',
-                            attachments: args.draftAttachments
+                            attachments: args.draftAttachments,
+                            conversationId: args.conversationId
                         });
                         return {
                             content: [
@@ -832,6 +859,85 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 }
                             ]
                         };
+                    case "update_draft":
+                        if (!args?.draftId) {
+                            throw new Error("draftId is required for update_draft action");
+                        }
+                        const updates = {};
+                        if (args.draftTo)
+                            updates.to = args.draftTo;
+                        if (args.draftCc)
+                            updates.cc = args.draftCc;
+                        if (args.draftBcc)
+                            updates.bcc = args.draftBcc;
+                        if (args.draftSubject)
+                            updates.subject = args.draftSubject;
+                        if (args.draftBody)
+                            updates.body = args.draftBody;
+                        if (args.draftBodyType)
+                            updates.bodyType = args.draftBodyType;
+                        if (args.draftImportance)
+                            updates.importance = args.draftImportance;
+                        if (args.draftAttachments)
+                            updates.attachments = args.draftAttachments;
+                        const updateResult = await ms365Ops.updateDraftEmail(args.draftId, updates);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ Draft email updated successfully!\n🆔 Draft ID: ${updateResult.id}\n📝 Status: ${updateResult.status}`
+                                }
+                            ]
+                        };
+                    case "send_draft":
+                        if (!args?.draftId) {
+                            throw new Error("draftId is required for send_draft action");
+                        }
+                        const sendResult = await ms365Ops.sendDraftEmail(args.draftId);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ Draft email sent successfully!\n🆔 Draft ID: ${sendResult.id}\n📤 Status: ${sendResult.status}`
+                                }
+                            ]
+                        };
+                    case "list_drafts":
+                        const draftsList = await ms365Ops.listDrafts(args?.maxResults || 50);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `📝 Draft Emails (${draftsList.messages.length} found)\n\n${draftsList.messages.map((draft) => `📝 ${draft.subject || 'No subject'}\n   👥 To: ${draft.toRecipients?.map((r) => r.address).join(', ') || 'No recipients'}\n   🆔 ID: ${draft.id}\n   📅 Created: ${new Date(draft.receivedDateTime || draft.sentDateTime).toLocaleDateString()}\n   💬 Conversation: ${draft.conversationId || 'None'}\n`).join('\n')}\n${draftsList.hasMore ? '➡️ More drafts available - use maxResults to see more' : ''}`
+                                }
+                            ]
+                        };
+                    case "reply_draft":
+                        if (!args?.originalMessageId) {
+                            throw new Error("originalMessageId is required for reply_draft action");
+                        }
+                        const replyDraftResult = await ms365Ops.createReplyDraft(args.originalMessageId, args.draftBody, args.replyToAll || false);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ Reply draft created successfully!\n📧 Original Message: ${args.originalMessageId}\n💬 Reply Type: ${args.replyToAll ? 'Reply All' : 'Reply'}\n🆔 Draft ID: ${replyDraftResult.id}\n💬 Conversation ID: ${replyDraftResult.conversationId}\n📧 To: ${replyDraftResult.toRecipients?.join(', ') || 'Auto-determined'}`
+                                }
+                            ]
+                        };
+                    case "forward_draft":
+                        if (!args?.originalMessageId) {
+                            throw new Error("originalMessageId is required for forward_draft action");
+                        }
+                        const forwardDraftResult = await ms365Ops.createForwardDraft(args.originalMessageId, args.draftBody);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ Forward draft created successfully!\n📧 Original Message: ${args.originalMessageId}\n🆔 Draft ID: ${forwardDraftResult.id}\n💬 Conversation ID: ${forwardDraftResult.conversationId}\n📋 Subject: ${forwardDraftResult.subject}`
+                                }
+                            ]
+                        };
                     default:
                         throw new Error(`Unknown email action: ${emailAction}`);
                 }
@@ -986,12 +1092,40 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const graphClient = await enhancedMS365Auth.getGraphClient();
                     ms365Ops.setGraphClient(graphClient);
                 }
-                const folders = await ms365Ops.listFolders();
+                let folders;
+                let resultTitle = "📁 Mail Folders";
+                if (args?.parentFolderId) {
+                    // List only child folders of specified parent
+                    const parentFolderId = args.parentFolderId;
+                    folders = await ms365Ops.listChildFolders(parentFolderId);
+                    resultTitle = `📁 Child Folders of ${parentFolderId}`;
+                }
+                else if (args?.searchName) {
+                    // Search for folders by name
+                    const searchName = args.searchName;
+                    folders = await ms365Ops.findFolderByName(searchName);
+                    resultTitle = `📁 Folders matching "${searchName}"`;
+                }
+                else {
+                    // List all folders with hierarchy
+                    folders = await ms365Ops.listFolders();
+                    resultTitle = "📁 Mail Folders (Complete Hierarchy)";
+                }
+                // Format folders with proper hierarchy display
+                const formatFolder = (folder) => {
+                    const indent = '  '.repeat(folder.depth || 0);
+                    const icon = folder.depth === 0 ? '📁' : '📂';
+                    const pathInfo = folder.fullPath ? `\n${indent}   📍 Path: ${folder.fullPath}` : '';
+                    return `${indent}${icon} ${folder.displayName}\n${indent}   🆔 ID: ${folder.id}\n${indent}   📧 Total Items: ${folder.totalItemCount}\n${indent}   📩 Unread: ${folder.unreadItemCount}${pathInfo}\n`;
+                };
+                const folderCount = folders.length;
+                const totalItems = folders.reduce((sum, folder) => sum + (folder.totalItemCount || 0), 0);
+                const totalUnread = folders.reduce((sum, folder) => sum + (folder.unreadItemCount || 0), 0);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `📁 Mail Folders\n\n${folders.map((folder) => `📂 ${folder.displayName}\n   🆔 ID: ${folder.id}\n   📧 Total Items: ${folder.totalItemCount}\n   📩 Unread: ${folder.unreadItemCount}\n`).join('\n')}`
+                            text: `${resultTitle}\n\n📊 Summary: ${folderCount} folders, ${totalItems} total items, ${totalUnread} unread\n\n${folders.map(formatFolder).join('\n')}`
                         }
                     ]
                 };

package/dist/utils/ms365-operations.js

@@ -290,6 +290,19 @@ export class MS365Operations {
                 importance: message.importance || 'normal',
                 attachments: attachments.length > 0 ? attachments : undefined
             };
+            // Handle threading - set conversationId for replies/forwards
+            if (message.conversationId) {
+                draftBody.conversationId = message.conversationId;
+            }
+            // Handle in-reply-to for proper threading
+            if (message.inReplyTo) {
+                draftBody.internetMessageHeaders = [
+                    {
+                        name: 'In-Reply-To',
+                        value: message.inReplyTo
+                    }
+                ];
+            }
             if (message.replyTo) {
                 draftBody.replyTo = [{
                         emailAddress: {
@@ -313,6 +326,211 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Update a draft email
+     */
+    async updateDraftEmail(draftId, updates) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Prepare update payload
+            const updateBody = {};
+            if (updates.subject) {
+                updateBody.subject = updates.subject;
+            }
+            if (updates.body) {
+                updateBody.body = {
+                    contentType: updates.bodyType === 'html' ? 'html' : 'text',
+                    content: updates.body
+                };
+            }
+            if (updates.to) {
+                updateBody.toRecipients = updates.to.map(email => ({
+                    emailAddress: {
+                        address: email,
+                        name: email.split('@')[0]
+                    }
+                }));
+            }
+            if (updates.cc) {
+                updateBody.ccRecipients = updates.cc.map(email => ({
+                    emailAddress: {
+                        address: email,
+                        name: email.split('@')[0]
+                    }
+                }));
+            }
+            if (updates.bcc) {
+                updateBody.bccRecipients = updates.bcc.map(email => ({
+                    emailAddress: {
+                        address: email,
+                        name: email.split('@')[0]
+                    }
+                }));
+            }
+            if (updates.importance) {
+                updateBody.importance = updates.importance;
+            }
+            if (updates.replyTo) {
+                updateBody.replyTo = [{
+                        emailAddress: {
+                            address: updates.replyTo,
+                            name: updates.replyTo.split('@')[0]
+                        }
+                    }];
+            }
+            // Update attachments if provided
+            if (updates.attachments) {
+                updateBody.attachments = updates.attachments.map(att => ({
+                    '@odata.type': '#microsoft.graph.fileAttachment',
+                    name: att.name,
+                    contentBytes: att.contentBytes,
+                    contentType: att.contentType || 'application/octet-stream'
+                }));
+            }
+            // Update the draft
+            const result = await graphClient
+                .api(`/me/messages/${draftId}`)
+                .patch(updateBody);
+            logger.log(`Draft email ${draftId} updated successfully`);
+            return {
+                id: result.id || draftId,
+                status: 'draft_updated'
+            };
+        }
+        catch (error) {
+            logger.error(`Error updating draft email ${draftId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Send a draft email
+     */
+    async sendDraftEmail(draftId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Send the draft
+            await graphClient
+                .api(`/me/messages/${draftId}/send`)
+                .post({});
+            logger.log(`Draft email ${draftId} sent successfully`);
+            return {
+                id: draftId,
+                status: 'sent'
+            };
+        }
+        catch (error) {
+            logger.error(`Error sending draft email ${draftId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * List draft emails
+     */
+    async listDrafts(maxResults = 50) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api('/me/mailFolders/drafts/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink,isDraft')
+                .orderby('createdDateTime desc')
+                .top(maxResults)
+                .get();
+            const messages = result.value?.map((email) => ({
+                id: email.id,
+                subject: email.subject || '',
+                from: {
+                    name: email.from?.emailAddress?.name || '',
+                    address: email.from?.emailAddress?.address || ''
+                },
+                toRecipients: email.toRecipients?.map((recipient) => ({
+                    name: recipient.emailAddress?.name || '',
+                    address: recipient.emailAddress?.address || ''
+                })) || [],
+                ccRecipients: email.ccRecipients?.map((recipient) => ({
+                    name: recipient.emailAddress?.name || '',
+                    address: recipient.emailAddress?.address || ''
+                })) || [],
+                receivedDateTime: email.receivedDateTime,
+                sentDateTime: email.sentDateTime,
+                bodyPreview: email.bodyPreview || '',
+                isRead: email.isRead || false,
+                hasAttachments: email.hasAttachments || false,
+                importance: email.importance || 'normal',
+                conversationId: email.conversationId || '',
+                parentFolderId: email.parentFolderId || '',
+                webLink: email.webLink || '',
+                attachments: []
+            })) || [];
+            return {
+                messages,
+                hasMore: !!result['@odata.nextLink']
+            };
+        }
+        catch (error) {
+            logger.error('Error listing draft emails:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a threaded reply draft from a specific message
+     */
+    async createReplyDraft(originalMessageId, body, replyToAll = false) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Use Microsoft Graph's createReply endpoint for proper threading
+            const endpoint = replyToAll
+                ? `/me/messages/${originalMessageId}/createReplyAll`
+                : `/me/messages/${originalMessageId}/createReply`;
+            const requestBody = {};
+            // If body is provided, include it as a comment
+            if (body) {
+                requestBody.comment = body;
+            }
+            const replyDraft = await graphClient
+                .api(endpoint)
+                .post(requestBody);
+            return {
+                id: replyDraft.id,
+                subject: replyDraft.subject,
+                conversationId: replyDraft.conversationId,
+                toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
+                ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
+                bodyPreview: replyDraft.bodyPreview,
+                isDraft: replyDraft.isDraft
+            };
+        }
+        catch (error) {
+            throw new Error(`Error creating reply draft: ${error}`);
+        }
+    }
+    /**
+     * Create a threaded forward draft from a specific message
+     */
+    async createForwardDraft(originalMessageId, comment) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Use Microsoft Graph's createForward endpoint for proper threading
+            const endpoint = `/me/messages/${originalMessageId}/createForward`;
+            const requestBody = {};
+            // If comment is provided, include it
+            if (comment) {
+                requestBody.comment = comment;
+            }
+            const forwardDraft = await graphClient
+                .api(endpoint)
+                .post(requestBody);
+            return {
+                id: forwardDraft.id,
+                subject: forwardDraft.subject,
+                conversationId: forwardDraft.conversationId,
+                bodyPreview: forwardDraft.bodyPreview,
+                isDraft: forwardDraft.isDraft
+            };
+        }
+        catch (error) {
+            throw new Error(`Error creating forward draft: ${error}`);
+        }
+    }
     /**
      * Get email by ID
      */
@@ -732,15 +950,91 @@ export class MS365Operations {
         }
     }
     /**
-     * List mail folders
+     * List mail folders including child folders recursively
      */
     async listFolders() {
         try {
             const graphClient = await this.getGraphClient();
+            const allFolders = [];
+            // Get top-level folders
             const result = await graphClient
                 .api('/me/mailFolders')
                 .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
                 .get();
+            // Process top-level folders
+            const topLevelFolders = result.value?.map((folder) => ({
+                id: folder.id,
+                displayName: folder.displayName || '',
+                totalItemCount: folder.totalItemCount || 0,
+                unreadItemCount: folder.unreadItemCount || 0,
+                parentFolderId: folder.parentFolderId,
+                depth: 0,
+                fullPath: folder.displayName || ''
+            })) || [];
+            allFolders.push(...topLevelFolders);
+            // Recursively get child folders for each top-level folder
+            for (const folder of topLevelFolders) {
+                const childFolders = await this.getChildFolders(folder.id, folder.fullPath || folder.displayName, 1);
+                allFolders.push(...childFolders);
+            }
+            // Sort folders by full path for better organization
+            allFolders.sort((a, b) => (a.fullPath || '').localeCompare(b.fullPath || ''));
+            return allFolders;
+        }
+        catch (error) {
+            logger.error('Error listing folders:', error);
+            throw error;
+        }
+    }
+    /**
+     * Recursively get child folders of a parent folder
+     */
+    async getChildFolders(parentFolderId, parentPath, depth) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const childFolders = [];
+            // Get child folders of the specified parent
+            const result = await graphClient
+                .api(`/me/mailFolders/${parentFolderId}/childFolders`)
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .get();
+            if (result.value && result.value.length > 0) {
+                const folders = result.value.map((folder) => ({
+                    id: folder.id,
+                    displayName: folder.displayName || '',
+                    totalItemCount: folder.totalItemCount || 0,
+                    unreadItemCount: folder.unreadItemCount || 0,
+                    parentFolderId: folder.parentFolderId,
+                    depth,
+                    fullPath: `${parentPath}/${folder.displayName || ''}`
+                }));
+                childFolders.push(...folders);
+                // Recursively get child folders (limit depth to prevent infinite recursion)
+                if (depth < 10) { // Max depth of 10 levels
+                    for (const folder of folders) {
+                        const subChildFolders = await this.getChildFolders(folder.id, folder.fullPath || folder.displayName, depth + 1);
+                        childFolders.push(...subChildFolders);
+                    }
+                }
+            }
+            return childFolders;
+        }
+        catch (error) {
+            // Log the error but don't throw - some folders might not have children or access might be restricted
+            logger.log(`Could not access child folders for ${parentFolderId}: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * List child folders of a specific parent folder
+     */
+    async listChildFolders(parentFolderId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api(`/me/mailFolders/${parentFolderId}/childFolders`)
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .get();
             return result.value?.map((folder) => ({
                 id: folder.id,
                 displayName: folder.displayName || '',
@@ -750,7 +1044,22 @@ export class MS365Operations {
             })) || [];
         }
         catch (error) {
-            logger.error('Error listing folders:', error);
+            logger.error(`Error listing child folders for ${parentFolderId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Find folder by name (case-insensitive search across all folders)
+     */
+    async findFolderByName(folderName) {
+        try {
+            const allFolders = await this.listFolders();
+            const searchName = folderName.toLowerCase();
+            return allFolders.filter(folder => folder.displayName.toLowerCase().includes(searchName) ||
+                (folder.fullPath && folder.fullPath.toLowerCase().includes(searchName)));
+        }
+        catch (error) {
+            logger.error(`Error finding folder by name ${folderName}:`, error);
             throw error;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.9",
+  "version": "1.1.10",
   "description": "Microsoft 365 MCP Server for managing Microsoft 365 email through natural language interactions with full OAuth2 authentication support",
   "main": "dist/index.js",
   "type": "module",