@tgai96/outlook-mcp 1.0.0

package/email/read.js

@@ -0,0 +1,128 @@
+/**
+ * Read email functionality
+ */
+const config = require('../config');
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * Read email handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleReadEmail(args) {
+  const emailId = args.id;
+  
+  if (!emailId) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Email ID is required."
+      }]
+    };
+  }
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Make API call to get email details
+    const endpoint = `me/messages/${encodeURIComponent(emailId)}`;
+    const queryParams = {
+      $select: config.EMAIL_DETAIL_FIELDS
+    };
+    
+    try {
+      const email = await callGraphAPI(accessToken, 'GET', endpoint, null, queryParams);
+      
+      if (!email) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Email with ID ${emailId} not found.`
+            }
+          ]
+        };
+      }
+      
+      // Format sender, recipients, etc.
+      const sender = email.from ? `${email.from.emailAddress.name} (${email.from.emailAddress.address})` : 'Unknown';
+      const to = email.toRecipients ? email.toRecipients.map(r => `${r.emailAddress.name} (${r.emailAddress.address})`).join(", ") : 'None';
+      const cc = email.ccRecipients && email.ccRecipients.length > 0 ? email.ccRecipients.map(r => `${r.emailAddress.name} (${r.emailAddress.address})`).join(", ") : 'None';
+      const bcc = email.bccRecipients && email.bccRecipients.length > 0 ? email.bccRecipients.map(r => `${r.emailAddress.name} (${r.emailAddress.address})`).join(", ") : 'None';
+      const date = new Date(email.receivedDateTime).toLocaleString();
+      
+      // Extract body content
+      let body = '';
+      if (email.body) {
+        body = email.body.contentType === 'html' ? 
+          // Simple HTML-to-text conversion for HTML bodies
+          email.body.content.replace(/<[^>]*>/g, '') : 
+          email.body.content;
+      } else {
+        body = email.bodyPreview || 'No content';
+      }
+      
+      // Format the email
+      const formattedEmail = `From: ${sender}
+To: ${to}
+${cc !== 'None' ? `CC: ${cc}\n` : ''}${bcc !== 'None' ? `BCC: ${bcc}\n` : ''}Subject: ${email.subject}
+Date: ${date}
+Importance: ${email.importance || 'normal'}
+Has Attachments: ${email.hasAttachments ? 'Yes' : 'No'}
+
+${body}`;
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: formattedEmail
+          }
+        ]
+      };
+    } catch (error) {
+      console.error(`Error reading email: ${error.message}`);
+      
+      // Improved error handling with more specific messages
+      if (error.message.includes("doesn't belong to the targeted mailbox")) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `The email ID seems invalid or doesn't belong to your mailbox. Please try with a different email ID.`
+            }
+          ]
+        };
+      } else {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to read email: ${error.message}`
+            }
+          ]
+        };
+      }
+    }
+  } catch (error) {
+    if (error.message === 'Authentication required') {
+      return {
+        content: [{ 
+          type: "text", 
+          text: "Authentication required. Please use the 'authenticate' tool first."
+        }]
+      };
+    }
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Error accessing email: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleReadEmail;

package/email/search.js

@@ -0,0 +1,285 @@
+/**
+ * Improved search emails functionality
+ */
+const config = require('../config');
+const { callGraphAPI, callGraphAPIPaginated } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { resolveFolderPath } = require('./folder-utils');
+
+/**
+ * Search emails handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleSearchEmails(args) {
+  const folder = args.folder || "inbox";
+  const requestedCount = args.count || 10;
+  const query = args.query || '';
+  const from = args.from || '';
+  const to = args.to || '';
+  const subject = args.subject || '';
+  const hasAttachments = args.hasAttachments;
+  const unreadOnly = args.unreadOnly;
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Resolve the folder path
+    const endpoint = await resolveFolderPath(accessToken, folder);
+    console.error(`Using endpoint: ${endpoint} for folder: ${folder}`);
+    
+    // Execute progressive search with pagination
+    const response = await progressiveSearch(
+      endpoint, 
+      accessToken, 
+      { query, from, to, subject },
+      { hasAttachments, unreadOnly },
+      requestedCount
+    );
+    
+    return formatSearchResults(response);
+  } catch (error) {
+    // Handle authentication errors
+    if (error.message === 'Authentication required') {
+      return {
+        content: [{ 
+          type: "text", 
+          text: "Authentication required. Please use the 'authenticate' tool first."
+        }]
+      };
+    }
+    
+    // General error response
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Error searching emails: ${error.message}`
+      }]
+    };
+  }
+}
+
+/**
+ * Execute a search with progressively simpler fallback strategies
+ * @param {string} endpoint - API endpoint
+ * @param {string} accessToken - Access token
+ * @param {object} searchTerms - Search terms (query, from, to, subject)
+ * @param {object} filterTerms - Filter terms (hasAttachments, unreadOnly)
+ * @param {number} maxCount - Maximum number of results to retrieve
+ * @returns {Promise<object>} - Search results
+ */
+async function progressiveSearch(endpoint, accessToken, searchTerms, filterTerms, maxCount) {
+  // Track search strategies attempted
+  const searchAttempts = [];
+  
+  // 1. Try combined search (most specific)
+  try {
+    const params = buildSearchParams(searchTerms, filterTerms, Math.min(50, maxCount));
+    console.error("Attempting combined search with params:", params);
+    searchAttempts.push("combined-search");
+    
+    const response = await callGraphAPIPaginated(accessToken, 'GET', endpoint, params, maxCount);
+    if (response.value && response.value.length > 0) {
+      console.error(`Combined search successful: found ${response.value.length} results`);
+      return response;
+    }
+  } catch (error) {
+    console.error(`Combined search failed: ${error.message}`);
+  }
+  
+  // 2. Try each search term individually, starting with most specific
+  const searchPriority = ['subject', 'from', 'to', 'query'];
+  
+  for (const term of searchPriority) {
+    if (searchTerms[term]) {
+      try {
+        console.error(`Attempting search with only ${term}: "${searchTerms[term]}"`);
+        searchAttempts.push(`single-term-${term}`);
+        
+        // For single term search, only use $search with that term
+        // Note: $orderby cannot be used with $search in Microsoft Graph API
+        const simplifiedParams = {
+          $top: Math.min(50, maxCount),
+          $select: config.EMAIL_SELECT_FIELDS
+        };
+        
+        // Add the search term in the appropriate KQL syntax
+        if (term === 'query') {
+          // General query doesn't need a prefix
+          simplifiedParams.$search = `"${searchTerms[term]}"`;
+        } else {
+          // Specific field searches use field:value syntax
+          simplifiedParams.$search = `${term}:"${searchTerms[term]}"`;
+        }
+        
+        // Add boolean filters if applicable
+        addBooleanFilters(simplifiedParams, filterTerms);
+        
+        const response = await callGraphAPIPaginated(accessToken, 'GET', endpoint, simplifiedParams, maxCount);
+        if (response.value && response.value.length > 0) {
+          console.error(`Search with ${term} successful: found ${response.value.length} results`);
+          return response;
+        }
+      } catch (error) {
+        console.error(`Search with ${term} failed: ${error.message}`);
+      }
+    }
+  }
+  
+  // 3. Try with only boolean filters
+  if (filterTerms.hasAttachments === true || filterTerms.unreadOnly === true) {
+    try {
+      console.error("Attempting search with only boolean filters");
+      searchAttempts.push("boolean-filters-only");
+      
+      const filterOnlyParams = {
+        $top: Math.min(50, maxCount),
+        $select: config.EMAIL_SELECT_FIELDS,
+        $orderby: 'receivedDateTime desc'
+      };
+      
+      // Add the boolean filters
+      addBooleanFilters(filterOnlyParams, filterTerms);
+      
+      const response = await callGraphAPIPaginated(accessToken, 'GET', endpoint, filterOnlyParams, maxCount);
+      console.error(`Boolean filter search found ${response.value?.length || 0} results`);
+      return response;
+    } catch (error) {
+      console.error(`Boolean filter search failed: ${error.message}`);
+    }
+  }
+  
+  // 4. Final fallback: just get recent emails with pagination
+  console.error("All search strategies failed, falling back to recent emails");
+  searchAttempts.push("recent-emails");
+  
+  const basicParams = {
+    $top: Math.min(50, maxCount),
+    $select: config.EMAIL_SELECT_FIELDS,
+    $orderby: 'receivedDateTime desc'
+  };
+  
+  const response = await callGraphAPIPaginated(accessToken, 'GET', endpoint, basicParams, maxCount);
+  console.error(`Fallback to recent emails found ${response.value?.length || 0} results`);
+  
+  // Add a note to the response about the search attempts
+  response._searchInfo = {
+    attemptsCount: searchAttempts.length,
+    strategies: searchAttempts,
+    originalTerms: searchTerms,
+    filterTerms: filterTerms
+  };
+  
+  return response;
+}
+
+/**
+ * Build search parameters from search terms and filter terms
+ * @param {object} searchTerms - Search terms (query, from, to, subject)
+ * @param {object} filterTerms - Filter terms (hasAttachments, unreadOnly)
+ * @param {number} count - Maximum number of results
+ * @returns {object} - Query parameters
+ */
+function buildSearchParams(searchTerms, filterTerms, count) {
+  const params = {
+    $top: count,
+    $select: config.EMAIL_SELECT_FIELDS
+  };
+  
+  // Handle search terms
+  const kqlTerms = [];
+  
+  if (searchTerms.query) {
+    // General query doesn't need a prefix
+    kqlTerms.push(searchTerms.query);
+  }
+  
+  if (searchTerms.subject) {
+    kqlTerms.push(`subject:"${searchTerms.subject}"`);
+  }
+  
+  if (searchTerms.from) {
+    kqlTerms.push(`from:"${searchTerms.from}"`);
+  }
+  
+  if (searchTerms.to) {
+    kqlTerms.push(`to:"${searchTerms.to}"`);
+  }
+  
+  // Add $search if we have any search terms
+  // Note: $orderby cannot be used with $search in Microsoft Graph API
+  if (kqlTerms.length > 0) {
+    params.$search = kqlTerms.join(' ');
+  } else {
+    // Only add $orderby if we're not using $search
+    params.$orderby = 'receivedDateTime desc';
+  }
+  
+  // Add boolean filters
+  addBooleanFilters(params, filterTerms);
+  
+  return params;
+}
+
+/**
+ * Add boolean filters to query parameters
+ * @param {object} params - Query parameters
+ * @param {object} filterTerms - Filter terms (hasAttachments, unreadOnly)
+ */
+function addBooleanFilters(params, filterTerms) {
+  const filterConditions = [];
+  
+  if (filterTerms.hasAttachments === true) {
+    filterConditions.push('hasAttachments eq true');
+  }
+  
+  if (filterTerms.unreadOnly === true) {
+    filterConditions.push('isRead eq false');
+  }
+  
+  // Add $filter parameter if we have any filter conditions
+  if (filterConditions.length > 0) {
+    params.$filter = filterConditions.join(' and ');
+  }
+}
+
+/**
+ * Format search results into a readable text format
+ * @param {object} response - The API response object
+ * @returns {object} - MCP response object
+ */
+function formatSearchResults(response) {
+  if (!response.value || response.value.length === 0) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: `No emails found matching your search criteria.`
+      }]
+    };
+  }
+  
+  // Format results
+  const emailList = response.value.map((email, index) => {
+    const sender = email.from?.emailAddress || { name: 'Unknown', address: 'unknown' };
+    const date = new Date(email.receivedDateTime).toLocaleString();
+    const readStatus = email.isRead ? '' : '[UNREAD] ';
+    
+    return `${index + 1}. ${readStatus}${date} - From: ${sender.name} (${sender.address})\nSubject: ${email.subject}\nID: ${email.id}\n`;
+  }).join("\n");
+  
+  // Add search strategy info if available
+  let additionalInfo = '';
+  if (response._searchInfo) {
+    additionalInfo = `\n(Search used ${response._searchInfo.strategies[response._searchInfo.strategies.length - 1]} strategy)`;
+  }
+  
+  return {
+    content: [{ 
+      type: "text", 
+      text: `Found ${response.value.length} emails matching your search criteria:${additionalInfo}\n\n${emailList}`
+    }]
+  };
+}
+
+module.exports = handleSearchEmails;

package/email/send.js

@@ -0,0 +1,120 @@
+/**
+ * Send email functionality
+ */
+const config = require('../config');
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * Send email handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleSendEmail(args) {
+  const { to, cc, bcc, subject, body, importance = 'normal', saveToSentItems = true } = args;
+  
+  // Validate required parameters
+  if (!to) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Recipient (to) is required."
+      }]
+    };
+  }
+  
+  if (!subject) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Subject is required."
+      }]
+    };
+  }
+  
+  if (!body) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Body content is required."
+      }]
+    };
+  }
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Format recipients
+    const toRecipients = to.split(',').map(email => {
+      email = email.trim();
+      return {
+        emailAddress: {
+          address: email
+        }
+      };
+    });
+    
+    const ccRecipients = cc ? cc.split(',').map(email => {
+      email = email.trim();
+      return {
+        emailAddress: {
+          address: email
+        }
+      };
+    }) : [];
+    
+    const bccRecipients = bcc ? bcc.split(',').map(email => {
+      email = email.trim();
+      return {
+        emailAddress: {
+          address: email
+        }
+      };
+    }) : [];
+    
+    // Prepare email object
+    const emailObject = {
+      message: {
+        subject,
+        body: {
+          contentType: body.includes('<html') ? 'html' : 'text',
+          content: body
+        },
+        toRecipients,
+        ccRecipients: ccRecipients.length > 0 ? ccRecipients : undefined,
+        bccRecipients: bccRecipients.length > 0 ? bccRecipients : undefined,
+        importance
+      },
+      saveToSentItems
+    };
+    
+    // Make API call to send email
+    await callGraphAPI(accessToken, 'POST', 'me/sendMail', emailObject);
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Email sent successfully!\n\nSubject: ${subject}\nRecipients: ${toRecipients.length}${ccRecipients.length > 0 ? ` + ${ccRecipients.length} CC` : ''}${bccRecipients.length > 0 ? ` + ${bccRecipients.length} BCC` : ''}\nMessage Length: ${body.length} characters`
+      }]
+    };
+  } catch (error) {
+    if (error.message === 'Authentication required') {
+      return {
+        content: [{ 
+          type: "text", 
+          text: "Authentication required. Please use the 'authenticate' tool first."
+        }]
+      };
+    }
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Error sending email: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleSendEmail;

package/folder/create.js

@@ -0,0 +1,124 @@
+/**
+ * Create folder functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { getFolderIdByName } = require('../email/folder-utils');
+
+/**
+ * Create folder handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleCreateFolder(args) {
+  const folderName = args.name;
+  const parentFolder = args.parentFolder || '';
+  
+  if (!folderName) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Folder name is required."
+      }]
+    };
+  }
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Create folder with appropriate parent
+    const result = await createMailFolder(accessToken, folderName, parentFolder);
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: result.message
+      }]
+    };
+  } catch (error) {
+    if (error.message === 'Authentication required') {
+      return {
+        content: [{ 
+          type: "text", 
+          text: "Authentication required. Please use the 'authenticate' tool first."
+        }]
+      };
+    }
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Error creating folder: ${error.message}`
+      }]
+    };
+  }
+}
+
+/**
+ * Create a new mail folder
+ * @param {string} accessToken - Access token
+ * @param {string} folderName - Name of the folder to create
+ * @param {string} parentFolderName - Name of the parent folder (optional)
+ * @returns {Promise<object>} - Result object with status and message
+ */
+async function createMailFolder(accessToken, folderName, parentFolderName) {
+  try {
+    // Check if a folder with this name already exists
+    const existingFolder = await getFolderIdByName(accessToken, folderName);
+    if (existingFolder) {
+      return {
+        success: false,
+        message: `A folder named "${folderName}" already exists.`
+      };
+    }
+    
+    // If parent folder specified, find its ID
+    let endpoint = 'me/mailFolders';
+    if (parentFolderName) {
+      const parentId = await getFolderIdByName(accessToken, parentFolderName);
+      if (!parentId) {
+        return {
+          success: false,
+          message: `Parent folder "${parentFolderName}" not found. Please specify a valid parent folder or leave it blank to create at the root level.`
+        };
+      }
+      
+      endpoint = `me/mailFolders/${parentId}/childFolders`;
+    }
+    
+    // Create the folder
+    const folderData = {
+      displayName: folderName
+    };
+    
+    const response = await callGraphAPI(
+      accessToken,
+      'POST',
+      endpoint,
+      folderData
+    );
+    
+    if (response && response.id) {
+      const locationInfo = parentFolderName 
+        ? `inside "${parentFolderName}"` 
+        : "at the root level";
+        
+      return {
+        success: true,
+        message: `Successfully created folder "${folderName}" ${locationInfo}.`,
+        folderId: response.id
+      };
+    } else {
+      return {
+        success: false,
+        message: "Failed to create folder. The server didn't return a folder ID."
+      };
+    }
+  } catch (error) {
+    console.error(`Error creating folder "${folderName}": ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = handleCreateFolder;