ms365-mcp-server 1.0.4 → 1.0.5

package/dist/index.js

@@ -55,7 +55,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.0.4"
+    version: "1.0.5"
 }, {
     capabilities: {
         resources: {
@@ -770,11 +770,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const isAuthenticated = await enhancedMS365Auth.isAuthenticated();
                 const currentUser = await enhancedMS365Auth.getCurrentUser();
                 const storageInfo = enhancedMS365Auth.getStorageInfo();
+                const tokenInfo = await enhancedMS365Auth.getTokenExpirationInfo();
+                let statusText = `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n👤 Current User: ${currentUser || 'None'}\n💾 Storage method: ${storageInfo.method}\n📁 Storage location: ${storageInfo.location}`;
+                if (isAuthenticated) {
+                    statusText += `\n⏰ Token expires in: ${tokenInfo.expiresInMinutes} minutes`;
+                    if (tokenInfo.needsRefresh) {
+                        statusText += `\n⚠️ Token will be refreshed automatically on next operation`;
+                    }
+                }
+                else {
+                    statusText += `\n💡 Use the "authenticate_with_device_code" tool to sign in`;
+                }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n👤 Current User: ${currentUser || 'None'}\n💾 Storage method: ${storageInfo.method}\n📁 Storage location: ${storageInfo.location}`
+                            text: statusText
                         }
                     ]
                 };
@@ -881,11 +892,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ms365Ops.setGraphClient(graphClient);
                 }
                 const searchResults = await ms365Ops.searchEmails(args);
+                // Enhanced feedback for search results
+                let responseText = `🔍 Email Search Results (${searchResults.messages.length} found)`;
+                if (searchResults.messages.length === 0) {
+                    responseText = `🔍 No emails found matching your criteria.\n\n💡 Search Tips:\n`;
+                    if (args?.from) {
+                        responseText += `• Try partial names: "${args.from.split(' ')[0]}" or "${args.from.split(' ').pop()}"\n`;
+                        responseText += `• Check spelling of sender name\n`;
+                    }
+                    if (args?.subject) {
+                        responseText += `• Try broader subject terms\n`;
+                    }
+                    if (args?.after || args?.before) {
+                        responseText += `• Try expanding date range\n`;
+                    }
+                    responseText += `• Remove some search criteria to get broader results`;
+                }
+                else {
+                    responseText += `\n\n${searchResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   ${email.isRead ? '📖 Read' : '📩 Unread'}\n   🆔 ID: ${email.id}\n`).join('\n')}`;
+                    if (searchResults.hasMore) {
+                        responseText += `\n💡 There are more results available. Use maxResults parameter to get more emails.`;
+                    }
+                }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `🔍 Email Search Results (${searchResults.messages.length} found)\n\n${searchResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   🆔 ID: ${email.id}\n`).join('\n')}`
+                            text: responseText
                         }
                     ]
                 };

package/dist/utils/ms365-auth-enhanced.js

@@ -347,12 +347,52 @@ export class EnhancedMS365Auth {
         return client;
     }
     /**
-     * Refresh access token
+     * Get token expiration information for proactive refresh
+     */
+    async getTokenExpirationInfo() {
+        try {
+            const storedToken = await this.loadStoredToken();
+            if (!storedToken) {
+                return { expiresInMinutes: 0, needsRefresh: true };
+            }
+            const now = Date.now();
+            const expiresInMs = storedToken.expiresOn - now;
+            const expiresInMinutes = Math.floor(expiresInMs / (1000 * 60));
+            return {
+                expiresInMinutes: Math.max(0, expiresInMinutes),
+                needsRefresh: expiresInMinutes < 5 // Refresh if expiring within 5 minutes
+            };
+        }
+        catch (error) {
+            logger.error('Error getting token expiration info:', error);
+            return { expiresInMinutes: 0, needsRefresh: true };
+        }
+    }
+    /**
+     * Refresh token if needed (proactive refresh)
+     */
+    async refreshTokenIfNeeded() {
+        try {
+            const tokenInfo = await this.getTokenExpirationInfo();
+            if (tokenInfo.needsRefresh) {
+                logger.log('Proactively refreshing token to prevent interruption...');
+                await this.refreshToken();
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            logger.error('Proactive token refresh failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Enhanced refresh token with better error handling
      */
     async refreshToken() {
         const storedToken = await this.loadStoredToken();
         if (!storedToken?.account) {
-            throw new Error('No account information available. Please re-authenticate.');
+            throw new Error('No account information available. Please re-authenticate using: authenticate_with_device_code');
         }
         if (!await this.loadCredentials()) {
             throw new Error('MS365 credentials not configured');
@@ -364,14 +404,23 @@ export class EnhancedMS365Auth {
                 account: storedToken.account
             });
             if (!tokenResponse) {
-                throw new Error('Failed to refresh token');
+                throw new Error('Failed to refresh token - please re-authenticate using: authenticate_with_device_code');
             }
             await this.saveToken(tokenResponse, storedToken.authType);
             logger.log('MS365 token refreshed successfully');
         }
         catch (error) {
-            logger.error('Token refresh failed:', error);
-            throw error;
+            // Enhanced error handling with user-friendly messages
+            if (error.errorCode === 'invalid_grant' || error.errorCode === 'interaction_required') {
+                throw new Error('Authentication has expired. Please re-authenticate using the "authenticate_with_device_code" tool.');
+            }
+            else if (error.errorCode === 'consent_required') {
+                throw new Error('Additional consent required. Please re-authenticate using the "authenticate_with_device_code" tool.');
+            }
+            else {
+                logger.error('Token refresh failed:', error);
+                throw new Error(`Token refresh failed: ${error.message}. Please re-authenticate using the "authenticate_with_device_code" tool.`);
+            }
         }
     }
     /**

package/dist/utils/ms365-operations.js

@@ -1,4 +1,3 @@
-import { ms365Auth } from './ms365-auth.js';
 import { logger } from './api.js';
 /**
  * Microsoft 365 operations manager class
@@ -6,6 +5,38 @@ import { logger } from './api.js';
 export class MS365Operations {
     constructor() {
         this.graphClient = null;
+        this.searchCache = new Map();
+        this.CACHE_DURATION = 60 * 1000; // 1 minute cache
+        this.MAX_RETRIES = 3;
+        this.BASE_DELAY = 1000; // 1 second
+    }
+    /**
+     * Execute API call with retry logic and exponential backoff
+     */
+    async executeWithRetry(operation, context = 'API call') {
+        let lastError;
+        for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on authentication errors or client errors (4xx)
+                if (error.code === 'InvalidAuthenticationToken' ||
+                    (error.status >= 400 && error.status < 500)) {
+                    throw error;
+                }
+                if (attempt === this.MAX_RETRIES) {
+                    logger.error(`${context} failed after ${this.MAX_RETRIES} attempts:`, error);
+                    throw error;
+                }
+                // Exponential backoff with jitter
+                const delay = this.BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 1000;
+                logger.log(`${context} failed (attempt ${attempt}), retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        throw lastError;
     }
     /**
      * Set the Microsoft Graph client externally
@@ -14,14 +45,52 @@ export class MS365Operations {
         this.graphClient = client;
     }
     /**
-     * Get authenticated Microsoft Graph client
+     * Get authenticated Microsoft Graph client with proactive token refresh
      */
     async getGraphClient() {
         if (!this.graphClient) {
-            this.graphClient = await ms365Auth.getGraphClient();
+            // Import the enhanced auth module dynamically to avoid circular imports
+            const { enhancedMS365Auth } = await import('./ms365-auth-enhanced.js');
+            // Proactive token check - refresh if expiring within 5 minutes
+            const tokenInfo = await enhancedMS365Auth.getTokenExpirationInfo();
+            if (tokenInfo.expiresInMinutes < 5) {
+                logger.log(`Token expires in ${tokenInfo.expiresInMinutes} minutes, refreshing proactively...`);
+                await enhancedMS365Auth.refreshTokenIfNeeded();
+            }
+            this.graphClient = await enhancedMS365Auth.getGraphClient();
         }
         return this.graphClient;
     }
+    /**
+     * Clear expired cache entries
+     */
+    clearExpiredCache() {
+        const now = Date.now();
+        for (const [key, value] of this.searchCache.entries()) {
+            if (now - value.timestamp > this.CACHE_DURATION) {
+                this.searchCache.delete(key);
+            }
+        }
+    }
+    /**
+     * Get cached search results if available and not expired
+     */
+    getCachedResults(cacheKey) {
+        this.clearExpiredCache();
+        const cached = this.searchCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION) {
+            logger.log(`Cache hit for search: ${cacheKey}`);
+            return cached.results;
+        }
+        return null;
+    }
+    /**
+     * Cache search results
+     */
+    setCachedResults(cacheKey, results) {
+        this.searchCache.set(cacheKey, { results, timestamp: Date.now() });
+        logger.log(`Cached results for search: ${cacheKey}`);
+    }
     /**
      * Build filter query for Microsoft Graph API
      */
@@ -235,54 +304,57 @@ export class MS365Operations {
      * Search emails with criteria
      */
     async searchEmails(criteria = {}) {
-        try {
+        return await this.executeWithAuth(async () => {
             const graphClient = await this.getGraphClient();
+            // Create cache key from criteria
+            const cacheKey = JSON.stringify(criteria);
+            const cachedResults = this.getCachedResults(cacheKey);
+            if (cachedResults) {
+                return cachedResults;
+            }
             // For name-based searches, use enhanced approach for better partial matching
             if (criteria.from && !criteria.from.includes('@')) {
                 logger.log(`Using enhanced name matching for: "${criteria.from}"`);
                 // Get more emails and filter manually for better name matching
                 const maxResults = criteria.maxResults || 100;
                 try {
-                    // Get broader set of emails for manual filtering
+                    // Optimized field selection for name search - only get essential fields first
+                    const essentialFields = 'id,subject,from,receivedDateTime,isRead,hasAttachments,importance';
                     const apiCall = graphClient.api('/me/messages')
-                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .select(essentialFields)
                         .orderby('receivedDateTime desc')
-                        .top(Math.min(maxResults * 2, 200)); // Get more emails to filter from
+                        .top(Math.min(maxResults * 3, 300)); // Get more emails for better filtering
                     const result = await apiCall.get();
-                    let 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 || ''
-                    })) || [];
-                    // Apply manual filtering with enhanced name matching
-                    messages = this.applyManualFiltering(messages, criteria);
+                    // First pass: filter by name using minimal data
+                    const nameMatches = result.value?.filter((email) => {
+                        const fromName = email.from?.emailAddress?.name?.toLowerCase() || '';
+                        const fromAddress = email.from?.emailAddress?.address?.toLowerCase() || '';
+                        const searchTerm = criteria.from.toLowerCase().trim();
+                        // Quick name matching (subset of the full logic for performance)
+                        return fromName.includes(searchTerm) ||
+                            fromAddress.includes(searchTerm) ||
+                            fromName.split(/\s+/).some((part) => part.startsWith(searchTerm)) ||
+                            searchTerm.split(/\s+/).every((part) => fromName.includes(part));
+                    }) || [];
+                    if (nameMatches.length === 0) {
+                        const emptyResult = { messages: [], hasMore: false };
+                        this.setCachedResults(cacheKey, emptyResult);
+                        return emptyResult;
+                    }
+                    // Second pass: get full details for matched emails
+                    const messageIds = nameMatches.slice(0, maxResults).map((email) => email.id);
+                    const fullMessages = await this.getEmailsByIds(messageIds);
+                    // Apply remaining criteria filtering
+                    let messages = this.applyManualFiltering(fullMessages, criteria);
                     // Apply maxResults limit
                     const limitedMessages = messages.slice(0, maxResults);
                     logger.log(`Enhanced name search found ${limitedMessages.length} emails matching "${criteria.from}"`);
-                    return {
+                    const result_final = {
                         messages: limitedMessages,
-                        hasMore: messages.length > maxResults || !!result['@odata.nextLink']
+                        hasMore: messages.length > maxResults || nameMatches.length > maxResults
                     };
+                    this.setCachedResults(cacheKey, result_final);
+                    return result_final;
                 }
                 catch (error) {
                     logger.error('Error in enhanced name search, falling back to standard search:', error);
@@ -375,10 +447,12 @@ export class MS365Operations {
                 if (useSearchAPI && (criteria.folder || filterQuery)) {
                     messages = this.applyManualFiltering(messages, criteria);
                 }
-                return {
+                const standardResult = {
                     messages,
                     hasMore: !!result['@odata.nextLink']
                 };
+                this.setCachedResults(cacheKey, standardResult);
+                return standardResult;
             }
             catch (searchError) {
                 // If search API fails due to syntax error, fall back to filter-only approach
@@ -431,21 +505,19 @@ export class MS365Operations {
                     // Apply manual filtering for any criteria that couldn't be handled by the filter
                     // This includes subject, to, cc, and query filters that need manual processing
                     messages = this.applyManualFiltering(messages, criteria);
-                    return {
+                    const fallbackResult = {
                         messages,
                         hasMore: !!result['@odata.nextLink']
                     };
+                    this.setCachedResults(cacheKey, fallbackResult);
+                    return fallbackResult;
                 }
                 else {
                     // Re-throw other errors
                     throw searchError;
                 }
             }
-        }
-        catch (error) {
-            logger.error('Error searching emails:', error);
-            throw error;
-        }
+        }, 'searchEmails');
     }
     /**
      * Apply manual filtering to search results (used when $filter can't be used with $search)
@@ -791,5 +863,90 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Get multiple emails by their IDs efficiently
+     */
+    async getEmailsByIds(messageIds) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Batch request for better performance when getting multiple emails
+            const emails = [];
+            // Process in batches of 20 to stay within Graph API limits
+            const batchSize = 20;
+            for (let i = 0; i < messageIds.length; i += batchSize) {
+                const batch = messageIds.slice(i, i + batchSize);
+                // Get full details for this batch
+                const promises = batch.map(id => graphClient
+                    .api(`/me/messages/${id}`)
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                    .get());
+                const results = await Promise.all(promises);
+                const batchEmails = results.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 || ''
+                }));
+                emails.push(...batchEmails);
+            }
+            return emails;
+        }
+        catch (error) {
+            logger.error('Error getting emails by IDs:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear cached graph client (used when authentication fails)
+     */
+    clearGraphClient() {
+        this.graphClient = null;
+        logger.log('Cleared cached graph client due to authentication failure');
+    }
+    /**
+     * Execute operation with authentication retry
+     */
+    async executeWithAuth(operation, operationName) {
+        try {
+            return await this.executeWithRetry(operation, operationName);
+        }
+        catch (error) {
+            // Check if it's an authentication error
+            if (error.code === 'InvalidAuthenticationToken' ||
+                error.code === 'Unauthorized' ||
+                error.status === 401) {
+                logger.log(`Authentication failed for ${operationName}, clearing cache and retrying...`);
+                this.clearGraphClient();
+                // Retry once with fresh authentication
+                try {
+                    return await this.executeWithRetry(operation, `${operationName} (retry after auth failure)`);
+                }
+                catch (retryError) {
+                    logger.error(`${operationName} failed even after authentication retry:`, retryError);
+                    throw new Error(`Authentication failed. Please re-authenticate using the "authenticate_with_device_code" tool. Details: ${retryError.message}`);
+                }
+            }
+            throw error;
+        }
+    }
 }
 export const ms365Operations = new MS365Operations();

package/package.json

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