@tgai96/outlook-mcp 1.0.0

package/rules/create.js

@@ -0,0 +1,248 @@
+/**
+ * Create rule functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { getFolderIdByName } = require('../email/folder-utils');
+const { getInboxRules } = require('./list');
+
+/**
+ * Create rule handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleCreateRule(args) {
+  const {
+    name,
+    fromAddresses,
+    containsSubject,
+    hasAttachments,
+    moveToFolder,
+    markAsRead,
+    isEnabled = true,
+    sequence
+  } = args;
+  
+  // Add validation for sequence parameter
+  if (sequence !== undefined && (isNaN(sequence) || sequence < 1)) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Sequence must be a positive number greater than zero."
+      }]
+    };
+  }
+  
+  if (!name) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Rule name is required."
+      }]
+    };
+  }
+  
+  // Validate that at least one condition or action is specified
+  const hasCondition = fromAddresses || containsSubject || hasAttachments === true;
+  const hasAction = moveToFolder || markAsRead === true;
+  
+  if (!hasCondition) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "At least one condition is required. Specify fromAddresses, containsSubject, or hasAttachments."
+      }]
+    };
+  }
+  
+  if (!hasAction) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "At least one action is required. Specify moveToFolder or markAsRead."
+      }]
+    };
+  }
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Create rule
+    const result = await createInboxRule(accessToken, {
+      name,
+      fromAddresses,
+      containsSubject,
+      hasAttachments,
+      moveToFolder,
+      markAsRead,
+      isEnabled,
+      sequence
+    });
+    
+    let responseText = result.message;
+    
+    // Add a tip about sequence if it wasn't provided
+    if (!sequence && !result.error) {
+      responseText += "\n\nTip: You can specify a 'sequence' parameter when creating rules to control their execution order. Lower sequence numbers run first.";
+    }
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: responseText
+      }]
+    };
+  } 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 rule: ${error.message}`
+      }]
+    };
+  }
+}
+
+/**
+ * Create a new inbox rule
+ * @param {string} accessToken - Access token
+ * @param {object} ruleOptions - Rule creation options
+ * @returns {Promise<object>} - Result object with status and message
+ */
+async function createInboxRule(accessToken, ruleOptions) {
+  try {
+    const {
+      name,
+      fromAddresses,
+      containsSubject,
+      hasAttachments,
+      moveToFolder,
+      markAsRead,
+      isEnabled,
+      sequence
+    } = ruleOptions;
+    
+    // Get existing rules to determine sequence if not provided
+    let ruleSequence = sequence;
+    if (!ruleSequence) {
+      try {
+        // Default to 100 if we can't get existing rules
+        ruleSequence = 100;
+        
+        // Get existing rules to find highest sequence
+        const existingRules = await getInboxRules(accessToken);
+        if (existingRules && existingRules.length > 0) {
+          // Find the highest sequence
+          const highestSequence = Math.max(...existingRules.map(r => r.sequence || 0));
+          // Set new rule sequence to be higher
+          ruleSequence = Math.max(highestSequence + 1, 100);
+          console.error(`Auto-generated sequence: ${ruleSequence} (based on highest existing: ${highestSequence})`);
+        }
+      } catch (sequenceError) {
+        console.error(`Error determining rule sequence: ${sequenceError.message}`);
+        // Fall back to default value
+        ruleSequence = 100;
+      }
+    }
+    
+    console.error(`Using rule sequence: ${ruleSequence}`);
+    
+    // Make sure sequence is a positive integer
+    ruleSequence = Math.max(1, Math.floor(ruleSequence));
+    
+    // Build rule object with sequence
+    const rule = {
+      displayName: name,
+      isEnabled: isEnabled === true,
+      sequence: ruleSequence,
+      conditions: {},
+      actions: {}
+    };
+    
+    // Add conditions
+    if (fromAddresses) {
+      // Parse email addresses
+      const emailAddresses = fromAddresses.split(',')
+        .map(email => email.trim())
+        .filter(email => email)
+        .map(email => ({
+          emailAddress: {
+            address: email
+          }
+        }));
+      
+      if (emailAddresses.length > 0) {
+        rule.conditions.fromAddresses = emailAddresses;
+      }
+    }
+    
+    if (containsSubject) {
+      rule.conditions.subjectContains = [containsSubject];
+    }
+    
+    if (hasAttachments === true) {
+      rule.conditions.hasAttachment = true;
+    }
+    
+    // Add actions
+    if (moveToFolder) {
+      // Get folder ID
+      try {
+        const folderId = await getFolderIdByName(accessToken, moveToFolder);
+        if (!folderId) {
+          return {
+            success: false,
+            message: `Target folder "${moveToFolder}" not found. Please specify a valid folder name.`
+          };
+        }
+        
+        rule.actions.moveToFolder = folderId;
+      } catch (folderError) {
+        console.error(`Error resolving folder "${moveToFolder}": ${folderError.message}`);
+        return {
+          success: false,
+          message: `Error resolving folder "${moveToFolder}": ${folderError.message}`
+        };
+      }
+    }
+    
+    if (markAsRead === true) {
+      rule.actions.markAsRead = true;
+    }
+    
+    // Create the rule
+    const response = await callGraphAPI(
+      accessToken,
+      'POST',
+      'me/mailFolders/inbox/messageRules',
+      rule
+    );
+    
+    if (response && response.id) {
+      return {
+        success: true,
+        message: `Successfully created rule "${name}" with sequence ${ruleSequence}.`,
+        ruleId: response.id
+      };
+    } else {
+      return {
+        success: false,
+        message: "Failed to create rule. The server didn't return a rule ID."
+      };
+    }
+  } catch (error) {
+    console.error(`Error creating rule: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = handleCreateRule;

package/rules/index.js

@@ -0,0 +1,175 @@
+/**
+ * Email rules management module for Outlook MCP server
+ */
+const handleListRules = require('./list');
+const handleCreateRule = require('./create');
+
+// Import getInboxRules for the edit sequence tool
+const { getInboxRules } = require('./list');
+
+/**
+ * Edit rule sequence handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleEditRuleSequence(args) {
+  const { ruleName, sequence } = args;
+  
+  if (!ruleName) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "Rule name is required. Please specify the exact name of an existing rule."
+      }]
+    };
+  }
+  
+  if (!sequence || isNaN(sequence) || sequence < 1) {
+    return {
+      content: [{ 
+        type: "text", 
+        text: "A positive sequence number is required. Lower numbers run first (higher priority)."
+      }]
+    };
+  }
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Get all rules
+    const rules = await getInboxRules(accessToken);
+    
+    // Find the rule by name
+    const rule = rules.find(r => r.displayName === ruleName);
+    if (!rule) {
+      return {
+        content: [{ 
+          type: "text", 
+          text: `Rule with name "${ruleName}" not found.`
+        }]
+      };
+    }
+    
+    // Update the rule sequence
+    const updateResult = await callGraphAPI(
+      accessToken,
+      'PATCH',
+      `me/mailFolders/inbox/messageRules/${rule.id}`,
+      {
+        sequence: sequence
+      }
+    );
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Successfully updated the sequence of rule "${ruleName}" to ${sequence}.`
+      }]
+    };
+  } 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 updating rule sequence: ${error.message}`
+      }]
+    };
+  }
+}
+
+// Rules management tool definitions
+const rulesTools = [
+  {
+    name: "list-rules",
+    description: "Lists inbox rules in your Outlook account",
+    inputSchema: {
+      type: "object",
+      properties: {
+        includeDetails: {
+          type: "boolean",
+          description: "Include detailed rule conditions and actions"
+        }
+      },
+      required: []
+    },
+    handler: handleListRules
+  },
+  {
+    name: "create-rule",
+    description: "Creates a new inbox rule",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the rule to create"
+        },
+        fromAddresses: {
+          type: "string",
+          description: "Comma-separated list of sender email addresses for the rule"
+        },
+        containsSubject: {
+          type: "string",
+          description: "Subject text the email must contain"
+        },
+        hasAttachments: {
+          type: "boolean",
+          description: "Whether the rule applies to emails with attachments"
+        },
+        moveToFolder: {
+          type: "string",
+          description: "Name of the folder to move matching emails to"
+        },
+        markAsRead: {
+          type: "boolean", 
+          description: "Whether to mark matching emails as read"
+        },
+        isEnabled: {
+          type: "boolean",
+          description: "Whether the rule should be enabled after creation (default: true)"
+        },
+        sequence: {
+          type: "number",
+          description: "Order in which the rule is executed (lower numbers run first, default: 100)"
+        }
+      },
+      required: ["name"]
+    },
+    handler: handleCreateRule
+  },
+  {
+    name: "edit-rule-sequence",
+    description: "Changes the execution order of an existing inbox rule",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ruleName: {
+          type: "string",
+          description: "Name of the rule to modify"
+        },
+        sequence: {
+          type: "number",
+          description: "New sequence value for the rule (lower numbers run first)"
+        }
+      },
+      required: ["ruleName", "sequence"]
+    },
+    handler: handleEditRuleSequence
+  }
+];
+
+module.exports = {
+  rulesTools,
+  handleListRules,
+  handleCreateRule,
+  handleEditRuleSequence
+};

package/rules/list.js

@@ -0,0 +1,202 @@
+/**
+ * List rules functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * List rules handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleListRules(args) {
+  const includeDetails = args.includeDetails === true;
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Get all inbox rules
+    const rules = await getInboxRules(accessToken);
+    
+    // Format the rules based on detail level
+    const formattedRules = formatRulesList(rules, includeDetails);
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: formattedRules
+      }]
+    };
+  } 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 listing rules: ${error.message}`
+      }]
+    };
+  }
+}
+
+/**
+ * Get all inbox rules
+ * @param {string} accessToken - Access token
+ * @returns {Promise<Array>} - Array of rule objects
+ */
+async function getInboxRules(accessToken) {
+  try {
+    const response = await callGraphAPI(
+      accessToken,
+      'GET',
+      'me/mailFolders/inbox/messageRules',
+      null
+    );
+    
+    return response.value || [];
+  } catch (error) {
+    console.error(`Error getting inbox rules: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Format rules list for display
+ * @param {Array} rules - Array of rule objects
+ * @param {boolean} includeDetails - Whether to include detailed conditions and actions
+ * @returns {string} - Formatted rules list
+ */
+function formatRulesList(rules, includeDetails) {
+  if (!rules || rules.length === 0) {
+    return "No inbox rules found.\n\nTip: You can create rules using the 'create-rule' tool. Rules are processed in order of their sequence number (lower numbers are processed first).";
+  }
+  
+  // Sort rules by sequence to show execution order
+  const sortedRules = [...rules].sort((a, b) => {
+    return (a.sequence || 9999) - (b.sequence || 9999);
+  });
+  
+  // Format rules based on detail level
+  if (includeDetails) {
+    // Detailed format
+    const detailedRules = sortedRules.map((rule, index) => {
+      // Format rule header with sequence
+      let ruleText = `${index + 1}. ${rule.displayName}${rule.isEnabled ? '' : ' (Disabled)'} - Sequence: ${rule.sequence || 'N/A'}`;
+      
+      // Format conditions
+      const conditions = formatRuleConditions(rule);
+      if (conditions) {
+        ruleText += `\n   Conditions: ${conditions}`;
+      }
+      
+      // Format actions
+      const actions = formatRuleActions(rule);
+      if (actions) {
+        ruleText += `\n   Actions: ${actions}`;
+      }
+      
+      return ruleText;
+    });
+    
+    return `Found ${rules.length} inbox rules (sorted by execution order):\n\n${detailedRules.join('\n\n')}\n\nRules are processed in order of their sequence number. You can change rule order using the 'edit-rule-sequence' tool.`;
+  } else {
+    // Simple format
+    const simpleRules = sortedRules.map((rule, index) => {
+      return `${index + 1}. ${rule.displayName}${rule.isEnabled ? '' : ' (Disabled)'} - Sequence: ${rule.sequence || 'N/A'}`;
+    });
+    
+    return `Found ${rules.length} inbox rules (sorted by execution order):\n\n${simpleRules.join('\n')}\n\nTip: Use 'list-rules with includeDetails=true' to see more information about each rule.`;
+  }
+}
+
+/**
+ * Format rule conditions for display
+ * @param {object} rule - Rule object
+ * @returns {string} - Formatted conditions
+ */
+function formatRuleConditions(rule) {
+  const conditions = [];
+  
+  // From addresses
+  if (rule.conditions?.fromAddresses?.length > 0) {
+    const senders = rule.conditions.fromAddresses.map(addr => addr.emailAddress.address).join(', ');
+    conditions.push(`From: ${senders}`);
+  }
+  
+  // Subject contains
+  if (rule.conditions?.subjectContains?.length > 0) {
+    conditions.push(`Subject contains: "${rule.conditions.subjectContains.join(', ')}"`);
+  }
+  
+  // Contains body text
+  if (rule.conditions?.bodyContains?.length > 0) {
+    conditions.push(`Body contains: "${rule.conditions.bodyContains.join(', ')}"`);
+  }
+  
+  // Has attachment
+  if (rule.conditions?.hasAttachment === true) {
+    conditions.push('Has attachment');
+  }
+  
+  // Importance
+  if (rule.conditions?.importance) {
+    conditions.push(`Importance: ${rule.conditions.importance}`);
+  }
+  
+  return conditions.join('; ');
+}
+
+/**
+ * Format rule actions for display
+ * @param {object} rule - Rule object
+ * @returns {string} - Formatted actions
+ */
+function formatRuleActions(rule) {
+  const actions = [];
+  
+  // Move to folder
+  if (rule.actions?.moveToFolder) {
+    actions.push(`Move to folder: ${rule.actions.moveToFolder}`);
+  }
+  
+  // Copy to folder
+  if (rule.actions?.copyToFolder) {
+    actions.push(`Copy to folder: ${rule.actions.copyToFolder}`);
+  }
+  
+  // Mark as read
+  if (rule.actions?.markAsRead === true) {
+    actions.push('Mark as read');
+  }
+  
+  // Mark importance
+  if (rule.actions?.markImportance) {
+    actions.push(`Mark importance: ${rule.actions.markImportance}`);
+  }
+  
+  // Forward
+  if (rule.actions?.forwardTo?.length > 0) {
+    const recipients = rule.actions.forwardTo.map(r => r.emailAddress.address).join(', ');
+    actions.push(`Forward to: ${recipients}`);
+  }
+  
+  // Delete
+  if (rule.actions?.delete === true) {
+    actions.push('Delete');
+  }
+  
+  return actions.join('; ');
+}
+
+module.exports = {
+  handleListRules,
+  getInboxRules
+};