ms365-mcp-server 1.0.0 → 1.0.2

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

@@ -23,6 +23,7 @@ const DEFAULT_TENANT_ID = "common";
 // Configuration directory and file paths
 const CONFIG_DIR = path.join(os.homedir(), '.ms365-mcp');
 const CREDENTIALS_FILE = path.join(CONFIG_DIR, 'credentials.json');
+const DEVICE_CODE_FILE = path.join(CONFIG_DIR, 'device-code.json');
 /**
  * Enhanced Microsoft 365 authentication manager with device code flow support
  */
@@ -259,7 +260,7 @@ export class EnhancedMS365Auth {
         return 'device';
     }
     /**
-     * Save token using secure credential store
+     * Save token using secure credential store (simplified single account)
      */
     async saveToken(token, authType) {
         try {
@@ -270,8 +271,8 @@ export class EnhancedMS365Auth {
                 account: token.account,
                 authType: authType
             };
-            const accountKey = token.account?.username || 'default-user';
-            await credentialStore.setCredentials(accountKey, tokenData);
+            // Always use a single account key for simplicity
+            await credentialStore.setCredentials('ms365-user', tokenData);
             logger.log('Saved MS365 access token securely');
         }
         catch (error) {
@@ -279,11 +280,11 @@ export class EnhancedMS365Auth {
         }
     }
     /**
-     * Load stored token using secure credential store
+     * Load stored token using secure credential store (simplified single account)
      */
-    async loadStoredToken(accountKey = 'default-user') {
+    async loadStoredToken() {
         try {
-            return await credentialStore.getCredentials(accountKey);
+            return await credentialStore.getCredentials('ms365-user');
         }
         catch (error) {
             logger.error('Error loading stored token:', error);
@@ -329,22 +330,14 @@ export class EnhancedMS365Auth {
     /**
      * Get authenticated Microsoft Graph client
      */
-    async getGraphClient(accountKey) {
-        // If no specific account key provided, use the first available account
-        if (!accountKey) {
-            const accounts = await this.listAuthenticatedAccounts();
-            if (accounts.length === 0) {
-                throw new Error('No authenticated accounts found. Please authenticate first.');
-            }
-            accountKey = accounts[0];
-        }
-        const storedToken = await this.loadStoredToken(accountKey);
+    async getGraphClient() {
+        const storedToken = await this.loadStoredToken();
         if (!storedToken) {
             throw new Error('No stored token found. Please authenticate first.');
         }
         // Check if token is expired
         if (storedToken.expiresOn < Date.now()) {
-            await this.refreshToken(accountKey);
+            await this.refreshToken();
         }
         const client = Client.init({
             authProvider: (done) => {
@@ -356,8 +349,8 @@ export class EnhancedMS365Auth {
     /**
      * Refresh access token
      */
-    async refreshToken(accountKey = 'default-user') {
-        const storedToken = await this.loadStoredToken(accountKey);
+    async refreshToken() {
+        const storedToken = await this.loadStoredToken();
         if (!storedToken?.account) {
             throw new Error('No account information available. Please re-authenticate.');
         }
@@ -384,29 +377,15 @@ export class EnhancedMS365Auth {
     /**
      * Check if user is authenticated
      */
-    async isAuthenticated(accountKey) {
-        // If no specific account key provided, check all available accounts
-        if (!accountKey) {
-            const accounts = await this.listAuthenticatedAccounts();
-            if (accounts.length === 0) {
-                return false;
-            }
-            // Check if any account has valid authentication
-            for (const account of accounts) {
-                if (await this.isAuthenticated(account)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        const storedToken = await this.loadStoredToken(accountKey);
+    async isAuthenticated() {
+        const storedToken = await this.loadStoredToken();
         if (!storedToken) {
             return false;
         }
         // If token is expired, try to refresh
         if (storedToken.expiresOn < Date.now()) {
             try {
-                await this.refreshToken(accountKey);
+                await this.refreshToken();
                 return true;
             }
             catch (error) {
@@ -425,33 +404,160 @@ export class EnhancedMS365Auth {
     /**
      * Clear stored authentication data
      */
-    async resetAuth(accountKey) {
+    async resetAuth() {
+        try {
+            await credentialStore.deleteCredentials('ms365-user');
+            await this.clearDeviceCodeState();
+            logger.log('Cleared stored authentication tokens');
+        }
+        catch (error) {
+            logger.error('Error clearing authentication data:', error);
+        }
+    }
+    /**
+     * Save device code state to file
+     */
+    async saveDeviceCodeState(state) {
+        try {
+            fs.writeFileSync(DEVICE_CODE_FILE, JSON.stringify(state, null, 2));
+            logger.log('Saved device code state to file');
+        }
+        catch (error) {
+            logger.error('Error saving device code state:', error);
+            throw new Error('Failed to save device code state');
+        }
+    }
+    /**
+     * Load device code state from file
+     */
+    async loadDeviceCodeState() {
         try {
-            if (accountKey) {
-                // Delete specific account
-                await credentialStore.deleteCredentials(accountKey);
-                logger.log(`Cleared stored authentication tokens for account: ${accountKey}`);
+            if (!fs.existsSync(DEVICE_CODE_FILE)) {
+                return null;
             }
-            else {
-                // Delete all authenticated accounts
-                const authenticatedAccounts = await this.listAuthenticatedAccounts();
-                if (authenticatedAccounts.length === 0) {
-                    // If no accounts found by listing, try deleting the default-user key as fallback
-                    await credentialStore.deleteCredentials('default-user');
-                    logger.log('Cleared stored authentication tokens (fallback to default-user)');
-                }
-                else {
-                    // Delete all found accounts
-                    for (const account of authenticatedAccounts) {
-                        await credentialStore.deleteCredentials(account);
-                        logger.log(`Cleared stored authentication tokens for account: ${account}`);
+            const stateData = fs.readFileSync(DEVICE_CODE_FILE, 'utf8');
+            const state = JSON.parse(stateData);
+            // Check if device code has expired
+            const now = Date.now();
+            const elapsed = (now - state.startTime) / 1000;
+            if (elapsed > state.expiresIn) {
+                // Device code has expired, clean up
+                await this.clearDeviceCodeState();
+                return null;
+            }
+            return state;
+        }
+        catch (error) {
+            logger.error('Error loading device code state:', error);
+            return null;
+        }
+    }
+    /**
+     * Clear device code state file
+     */
+    async clearDeviceCodeState() {
+        try {
+            if (fs.existsSync(DEVICE_CODE_FILE)) {
+                fs.unlinkSync(DEVICE_CODE_FILE);
+                logger.log('Cleared device code state file');
+            }
+        }
+        catch (error) {
+            logger.error('Error clearing device code state:', error);
+        }
+    }
+    /**
+     * Complete device code authentication using saved state
+     */
+    async completeDeviceCodeAuth() {
+        const deviceCodeState = await this.loadDeviceCodeState();
+        if (!deviceCodeState) {
+            return false; // No pending device code authentication
+        }
+        if (!await this.loadCredentials()) {
+            throw new Error('MS365 credentials not configured');
+        }
+        try {
+            // Use the raw MSAL token endpoint to check if authentication completed
+            const tokenUrl = `https://login.microsoftonline.com/${this.credentials.tenantId}/oauth2/v2.0/token`;
+            const response = await fetch(tokenUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    device_code: deviceCodeState.deviceCode,
+                    client_id: this.credentials.clientId,
+                }),
+            });
+            const result = await response.json();
+            if (response.ok && result.access_token) {
+                // Authentication completed successfully
+                // Microsoft's token response doesn't include account info, so we need to get it from the token
+                let username = 'authenticated-user';
+                try {
+                    // Try to decode the access token to get user info
+                    const tokenParts = result.access_token.split('.');
+                    if (tokenParts.length >= 2) {
+                        const payload = JSON.parse(Buffer.from(tokenParts[1], 'base64').toString());
+                        username = payload.upn || payload.unique_name || payload.preferred_username || 'authenticated-user';
                     }
                 }
+                catch (decodeError) {
+                    logger.log('Could not decode token for username, using default');
+                }
+                const tokenResponse = {
+                    accessToken: result.access_token,
+                    refreshToken: result.refresh_token || '',
+                    expiresOn: new Date(Date.now() + (result.expires_in * 1000)),
+                    account: {
+                        username: username,
+                        homeAccountId: `${username}.${this.credentials.tenantId}`,
+                        environment: 'login.microsoftonline.com',
+                        tenantId: this.credentials.tenantId,
+                        localAccountId: username
+                    }
+                };
+                await this.saveToken(tokenResponse, 'device');
+                await this.clearDeviceCodeState();
+                logger.log('MS365 device code authentication completed successfully');
+                return true;
+            }
+            else if (result.error === 'authorization_pending') {
+                // Still waiting for user to complete authentication
+                return false;
+            }
+            else if (result.error === 'expired_token') {
+                // Device code has expired
+                await this.clearDeviceCodeState();
+                return false;
+            }
+            else {
+                // Other error - don't clear device code state, just return false
+                logger.error('Device code authentication error:', result);
+                return false;
             }
         }
         catch (error) {
-            logger.error('Error clearing authentication data:', error);
+            logger.error('Error completing device code authentication:', error);
+            // Don't clear device code state on network/other errors
+            return false;
+        }
+    }
+    /**
+     * Get pending device code info from saved state
+     */
+    async getPendingDeviceCodeInfo() {
+        const deviceCodeState = await this.loadDeviceCodeState();
+        if (!deviceCodeState) {
+            return null;
         }
+        return {
+            verificationUri: deviceCodeState.verificationUri,
+            userCode: deviceCodeState.userCode,
+            message: deviceCodeState.message
+        };
     }
     /**
      * Get authentication URL for device code flow
@@ -487,36 +593,47 @@ export class EnhancedMS365Auth {
         return new Promise((resolve, reject) => {
             const deviceCodeRequest = {
                 scopes: SCOPES,
-                deviceCodeCallback: (response) => {
+                deviceCodeCallback: async (response) => {
                     const deviceCodeInfo = {
                         verificationUri: response.verificationUri,
                         userCode: response.userCode,
                         message: response.message
                     };
-                    // Store the pending auth promise
-                    const authPromise = msalClient.acquireTokenByDeviceCode(deviceCodeRequest)
-                        .then(async (tokenResponse) => {
-                        if (!tokenResponse) {
-                            throw new Error('Failed to acquire token via device code');
-                        }
-                        await this.saveToken(tokenResponse, 'device');
-                        logger.log('MS365 device code authentication successful');
-                        this.pendingAuth = null; // Clear pending auth
-                        return tokenResponse;
-                    })
-                        .catch((error) => {
-                        this.pendingAuth = null; // Clear pending auth on error
-                        throw error;
-                    });
-                    this.pendingAuth = { authPromise, deviceCodeInfo };
-                    logger.log(`Device code authentication: ${response.verificationUri} - ${response.userCode}`);
-                    // Return device code info immediately
-                    resolve(deviceCodeInfo);
+                    // Save device code state for later completion
+                    const deviceCodeState = {
+                        deviceCode: response.deviceCode,
+                        userCode: response.userCode,
+                        verificationUri: response.verificationUri,
+                        expiresIn: response.expiresIn,
+                        startTime: Date.now(),
+                        message: response.message
+                    };
+                    try {
+                        await this.saveDeviceCodeState(deviceCodeState);
+                        logger.log(`Device code authentication started: ${response.verificationUri} - ${response.userCode}`);
+                        // Return device code info immediately
+                        resolve(deviceCodeInfo);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
                 }
             };
-            // This will never complete, but will call the callback immediately
-            msalClient.acquireTokenByDeviceCode(deviceCodeRequest).catch(() => {
-                // Ignore the error from this call since we're handling it in the stored promise
+            // Start the device code flow - we need this to run to get the device code
+            // The callback will resolve our promise, and we'll handle the auth later
+            msalClient.acquireTokenByDeviceCode(deviceCodeRequest).then((result) => {
+                // If this completes immediately (unlikely but possible), save the token
+                if (result) {
+                    this.saveToken(result, 'device').catch(() => {
+                        // Ignore save errors here since we primarily care about getting the device code
+                    });
+                }
+            }).catch((error) => {
+                // Only reject if we haven't already resolved with device code info
+                // The most common case is that the user hasn't completed auth yet
+                if (error.errorCode !== 'user_cancelled' && error.errorCode !== 'authorization_pending') {
+                    logger.error('Device code flow error:', error);
+                }
             });
         });
     }
@@ -535,12 +652,6 @@ export class EnhancedMS365Auth {
     hasPendingAuth() {
         return this.pendingAuth !== null;
     }
-    /**
-     * Get pending device code info
-     */
-    getPendingDeviceCodeInfo() {
-        return this.pendingAuth?.deviceCodeInfo || null;
-    }
     /**
      * Setup credentials interactively
      */
@@ -612,10 +723,14 @@ export class EnhancedMS365Auth {
         };
     }
     /**
-     * List all authenticated accounts
+     * Get current authenticated user (secure - only your own info)
      */
-    async listAuthenticatedAccounts() {
-        return await credentialStore.listAccounts();
+    async getCurrentUser() {
+        const storedToken = await this.loadStoredToken();
+        if (storedToken && storedToken.expiresOn > Date.now()) {
+            return storedToken.account?.username || 'authenticated-user';
+        }
+        return null;
     }
     /**
      * Get authentication URL without opening browser (redirect flow)

package/dist/utils/ms365-operations.js

@@ -389,16 +389,14 @@ export class MS365Operations {
                     return false;
             }
             if (criteria.to) {
-                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase().includes(criteria.to.toLowerCase()) ||
-                    recipient.name.toLowerCase().includes(criteria.to.toLowerCase()));
+                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase() === criteria.to.toLowerCase());
                 if (!toMatch)
                     return false;
             }
             if (criteria.cc) {
                 // Handle case where ccRecipients might be undefined
                 const ccMatch = message.ccRecipients && message.ccRecipients.length > 0 &&
-                    message.ccRecipients.some(recipient => recipient.address.toLowerCase().includes(criteria.cc.toLowerCase()) ||
-                        recipient.name.toLowerCase().includes(criteria.cc.toLowerCase()));
+                    message.ccRecipients.some(recipient => recipient.address.toLowerCase() === criteria.cc.toLowerCase());
                 if (!ccMatch)
                     return false;
             }
@@ -640,5 +638,61 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Get current user's email address
+     */
+    async getCurrentUserEmail() {
+        try {
+            const graphClient = await this.getGraphClient();
+            const user = await graphClient
+                .api('/me')
+                .select('mail,userPrincipalName')
+                .get();
+            return user.mail || user.userPrincipalName || '';
+        }
+        catch (error) {
+            logger.error('Error getting current user email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Search for emails addressed to the current user (both TO and CC recipients)
+     */
+    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
+            };
+        }
+        catch (error) {
+            logger.error('Error searching emails addressed to me:', error);
+            throw error;
+        }
+    }
 }
 export const ms365Operations = new MS365Operations();

package/package.json

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