ms365-mcp-server 1.1.4 → 1.1.6

package/dist/index.js

@@ -60,7 +60,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.4"
+    version: "1.1.6"
 }, {
     capabilities: {
         resources: {
@@ -1067,7 +1067,7 @@ function generateUniqueFilename(originalName) {
     const timestamp = Date.now();
     const randomString = crypto.randomBytes(8).toString('hex');
     const extension = path.extname(originalName);
-    const baseName = path.basename(originalName, extension);
+    const baseName = path.basename(originalName, extension).replace(/[^a-zA-Z0-9-_]/g, '_');
     return `${baseName}-${timestamp}-${randomString}${extension}`;
 }
 // Helper function to save base64 content to file

package/dist/utils/ms365-operations.js

@@ -1,4 +1,5 @@
 import { logger } from './api.js';
+import mimeTypes from 'mime-types';
 /**
  * Microsoft 365 operations manager class
  */
@@ -686,19 +687,48 @@ export class MS365Operations {
     async getAttachment(messageId, attachmentId) {
         try {
             const graphClient = await this.getGraphClient();
+            logger.log(`Fetching attachment ${attachmentId} from message ${messageId}...`);
+            // First get attachment metadata
             const attachment = await graphClient
                 .api(`/me/messages/${messageId}/attachments/${attachmentId}`)
                 .get();
-            return {
-                name: attachment.name || '',
-                contentType: attachment.contentType || 'application/octet-stream',
-                contentBytes: attachment.contentBytes || '',
+            logger.log(`Retrieved attachment metadata: ${attachment.name} (${attachment.contentType}, ${attachment.size} bytes)`);
+            // Determine content type if not provided
+            let contentType = attachment.contentType;
+            if (!contentType && attachment.name) {
+                contentType = mimeTypes.lookup(attachment.name) || 'application/octet-stream';
+                logger.log(`Inferred content type for ${attachment.name}: ${contentType}`);
+            }
+            // Validate content bytes
+            if (!attachment.contentBytes) {
+                logger.error('No content bytes found in attachment');
+                throw new Error('Attachment content is empty');
+            }
+            // Return the attachment data
+            const result = {
+                name: attachment.name || 'unnamed_attachment',
+                contentType: contentType || 'application/octet-stream',
+                contentBytes: attachment.contentBytes,
                 size: attachment.size || 0
             };
+            logger.log(`Successfully processed attachment: ${result.name} (${result.contentType}, ${result.size} bytes)`);
+            return result;
         }
         catch (error) {
             logger.error('Error getting attachment:', error);
-            throw error;
+            // Provide more specific error messages
+            if (error.status === 404) {
+                throw new Error(`Attachment not found: ${error.message}`);
+            }
+            else if (error.status === 401) {
+                throw new Error('Authentication failed. Please re-authenticate.');
+            }
+            else if (error.status === 403) {
+                throw new Error('Permission denied to access this attachment.');
+            }
+            else {
+                throw new Error(`Failed to get attachment: ${error.message}`);
+            }
         }
     }
     /**
@@ -810,33 +840,100 @@ export class MS365Operations {
     async searchEmailsToMe(additionalCriteria = {}) {
         try {
             const userEmail = await this.getCurrentUserEmail();
-            // First search for emails where user is in TO field
-            const toCriteria = {
-                ...additionalCriteria,
-                to: userEmail
-            };
-            // Then search for emails where user is in CC field
-            const ccCriteria = {
-                ...additionalCriteria,
-                cc: userEmail
-            };
-            // Execute both searches in parallel
-            const [toResults, ccResults] = await Promise.all([
-                this.searchEmails(toCriteria),
-                this.searchEmails(ccCriteria)
-            ]);
-            // Combine results and remove duplicates based on email ID
-            const allMessages = [...toResults.messages, ...ccResults.messages];
-            const uniqueMessages = allMessages.filter((message, index, array) => array.findIndex(m => m.id === message.id) === index);
-            // Sort by received date (newest first)
-            uniqueMessages.sort((a, b) => new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime());
-            // Apply maxResults limit if specified
-            const maxResults = additionalCriteria.maxResults || 50;
-            const limitedMessages = uniqueMessages.slice(0, maxResults);
-            return {
-                messages: limitedMessages,
-                hasMore: uniqueMessages.length > maxResults || toResults.hasMore || ccResults.hasMore
-            };
+            const graphClient = await this.getGraphClient();
+            // Create cache key from criteria
+            const cacheKey = JSON.stringify({ ...additionalCriteria, userEmail });
+            const cachedResults = this.getCachedResults(cacheKey);
+            if (cachedResults) {
+                return cachedResults;
+            }
+            try {
+                // Start with a basic query to get emails
+                const apiCall = graphClient.api('/me/messages')
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink');
+                // Add search query for user's email in TO or CC using proper syntax
+                apiCall.search(`"${userEmail}"`);
+                // Add simple filters that are supported by the API
+                if (additionalCriteria.after) {
+                    apiCall.filter(`receivedDateTime ge ${new Date(additionalCriteria.after).toISOString()}`);
+                }
+                if (additionalCriteria.before) {
+                    apiCall.filter(`receivedDateTime le ${new Date(additionalCriteria.before).toISOString()}`);
+                }
+                if (additionalCriteria.hasAttachment !== undefined) {
+                    apiCall.filter(`hasAttachments eq ${additionalCriteria.hasAttachment}`);
+                }
+                if (additionalCriteria.isUnread !== undefined) {
+                    apiCall.filter(`isRead eq ${!additionalCriteria.isUnread}`);
+                }
+                if (additionalCriteria.importance) {
+                    apiCall.filter(`importance eq '${additionalCriteria.importance}'`);
+                }
+                // Set page size
+                const pageSize = Math.min(additionalCriteria.maxResults || 100, 100);
+                apiCall.top(pageSize);
+                const result = await apiCall.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: []
+                })) || [];
+                // Filter messages to only include those where the user is in TO or CC
+                const filteredMessages = messages.filter(message => {
+                    const isInTo = message.toRecipients.some(recipient => recipient.address.toLowerCase() === userEmail.toLowerCase());
+                    const isInCc = message.ccRecipients.some(recipient => recipient.address.toLowerCase() === userEmail.toLowerCase());
+                    return isInTo || isInCc;
+                });
+                // Sort messages by receivedDateTime in descending order
+                filteredMessages.sort((a, b) => new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime());
+                // For emails with attachments, get attachment counts
+                for (const message of filteredMessages) {
+                    if (message.hasAttachments) {
+                        try {
+                            const attachments = await graphClient
+                                .api(`/me/messages/${message.id}/attachments`)
+                                .select('id')
+                                .get();
+                            message.attachments = new Array(attachments.value?.length || 0);
+                        }
+                        catch (error) {
+                            logger.error(`Error getting attachment count for message ${message.id}:`, error);
+                            message.attachments = [];
+                        }
+                    }
+                }
+                const searchResult = {
+                    messages: filteredMessages,
+                    hasMore: !!result['@odata.nextLink']
+                };
+                this.setCachedResults(cacheKey, searchResult);
+                return searchResult;
+            }
+            catch (error) {
+                logger.error('Error in email search:', error);
+                throw error;
+            }
         }
         catch (error) {
             logger.error('Error searching emails addressed to me:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "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",