@littlebearapps/outlook-assistant 3.6.0 → 3.7.0

package/rules/list.js

@@ -13,13 +13,8 @@ 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 {
@@ -36,7 +31,7 @@ async function handleListRules(args) {
         content: [
           {
             type: 'text',
-            text: "Authentication required. Please use the 'authenticate' tool first.",
+            text: "Authentication required. Please use the 'auth' tool with action=authenticate first.",
           },
         ],
       };
@@ -82,45 +77,43 @@ async function getInboxRules(accessToken) {
  */
 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).";
+    return 'No inbox rules found.\n\nTip: You can create rules using manage-rules with action=create. 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) => {
-      // Format rule header with sequence
       let ruleText = `[${rule.sequence || 'N/A'}] ${rule.displayName}${rule.isEnabled ? '' : ' (Disabled)'}`;
 
-      // Format conditions
       const conditions = formatRuleConditions(rule);
       if (conditions) {
         ruleText += `\n   Conditions: ${conditions}`;
       }
 
-      // Format actions
       const actions = formatRuleActions(rule);
       if (actions) {
         ruleText += `\n   Actions: ${actions}`;
       }
 
+      const exceptions = formatRuleExceptions(rule);
+      if (exceptions) {
+        ruleText += `\n   Exceptions: ${exceptions}`;
+      }
+
       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 manage-rules with action=reorder.`;
-  } else {
-    // Simple format
-    const simpleRules = sortedRules.map((rule) => {
-      return `[${rule.sequence || 'N/A'}] ${rule.displayName}${rule.isEnabled ? '' : ' (Disabled)'}`;
-    });
-
-    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.`;
   }
+
+  const simpleRules = sortedRules.map((rule) => {
+    return `[${rule.sequence || 'N/A'}] ${rule.displayName}${rule.isEnabled ? '' : ' (Disabled)'}`;
+  });
+
+  return `Found ${rules.length} inbox rules (sorted by execution order):\n\n${simpleRules.join('\n')}\n\nTip: Use manage-rules with includeDetails=true to see conditions, actions, and exceptions for each rule.`;
 }
 
 /**
@@ -130,37 +123,76 @@ function formatRulesList(rules, includeDetails) {
  */
 function formatRuleConditions(rule) {
   const conditions = [];
+  const c = rule.conditions;
+  if (!c) return '';
 
-  // From addresses
-  if (rule.conditions?.fromAddresses?.length > 0) {
-    const senders = rule.conditions.fromAddresses
-      .map((addr) => addr.emailAddress.address)
+  // Recipient-based
+  if (c.fromAddresses?.length > 0) {
+    const senders = c.fromAddresses
+      .map((addr) => addr.emailAddress?.address)
       .join(', ');
     conditions.push(`From: ${senders}`);
   }
+  if (c.sentToAddresses?.length > 0) {
+    const recipients = c.sentToAddresses
+      .map((addr) => addr.emailAddress?.address)
+      .join(', ');
+    conditions.push(`Sent to: ${recipients}`);
+  }
 
-  // Subject contains
-  if (rule.conditions?.subjectContains?.length > 0) {
+  // String collections
+  if (c.subjectContains?.length > 0) {
+    conditions.push(`Subject contains: "${c.subjectContains.join('", "')}"`);
+  }
+  if (c.bodyContains?.length > 0) {
+    conditions.push(`Body contains: "${c.bodyContains.join('", "')}"`);
+  }
+  if (c.bodyOrSubjectContains?.length > 0) {
     conditions.push(
-      `Subject contains: "${rule.conditions.subjectContains.join(', ')}"`
+      `Body/subject contains: "${c.bodyOrSubjectContains.join('", "')}"`
     );
   }
-
-  // Contains body text
-  if (rule.conditions?.bodyContains?.length > 0) {
+  if (c.senderContains?.length > 0) {
+    conditions.push(`Sender contains: "${c.senderContains.join('", "')}"`);
+  }
+  if (c.recipientContains?.length > 0) {
     conditions.push(
-      `Body contains: "${rule.conditions.bodyContains.join(', ')}"`
+      `Recipient contains: "${c.recipientContains.join('", "')}"`
     );
   }
+  if (c.headerContains?.length > 0) {
+    conditions.push(`Header contains: "${c.headerContains.join('", "')}"`);
+  }
 
-  // Has attachment
-  if (rule.conditions?.hasAttachment === true) {
-    conditions.push('Has attachment');
+  // Booleans
+  if (c.hasAttachment === true) conditions.push('Has attachment');
+  if (c.sentToMe === true) conditions.push('Sent to me');
+  if (c.sentOnlyToMe === true) conditions.push('Sent only to me');
+  if (c.sentCcMe === true) conditions.push('I am in CC');
+  if (c.sentToOrCcMe === true) conditions.push('Sent to me or CC');
+  if (c.isAutomaticReply === true) conditions.push('Is automatic reply');
+  if (c.isAutomaticForward === true) conditions.push('Is automatic forward');
+  if (c.isMeetingRequest === true) conditions.push('Is meeting request');
+  if (c.isMeetingResponse === true) conditions.push('Is meeting response');
+  if (c.isReadReceipt === true) conditions.push('Is read receipt');
+  if (c.isEncrypted === true) conditions.push('Is encrypted');
+  if (c.notSentToMe === true) conditions.push('Not sent to me');
+
+  // Enums
+  if (c.importance) conditions.push(`Importance: ${c.importance}`);
+  if (c.sensitivity) conditions.push(`Sensitivity: ${c.sensitivity}`);
+  if (c.messageActionFlag) conditions.push(`Flag: ${c.messageActionFlag}`);
+
+  // Categories
+  if (c.categories?.length > 0) {
+    conditions.push(`Categories: ${c.categories.join(', ')}`);
   }
 
-  // Importance
-  if (rule.conditions?.importance) {
-    conditions.push(`Importance: ${rule.conditions.importance}`);
+  // Size range
+  if (c.withinSizeRange) {
+    const min = c.withinSizeRange.minimumSize || 0;
+    const max = c.withinSizeRange.maximumSize || '∞';
+    conditions.push(`Size: ${min}–${max} bytes`);
   }
 
   return conditions.join('; ');
@@ -173,43 +205,93 @@ function formatRuleConditions(rule) {
  */
 function formatRuleActions(rule) {
   const actions = [];
+  const a = rule.actions;
+  if (!a) return '';
 
-  // Move to folder
-  if (rule.actions?.moveToFolder) {
-    actions.push(`Move to folder: ${rule.actions.moveToFolder}`);
-  }
+  if (a.moveToFolder) actions.push(`Move to folder: ${a.moveToFolder}`);
+  if (a.copyToFolder) actions.push(`Copy to folder: ${a.copyToFolder}`);
+  if (a.markAsRead === true) actions.push('Mark as read');
+  if (a.markImportance) actions.push(`Mark importance: ${a.markImportance}`);
 
-  // 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');
+  if (a.forwardTo?.length > 0) {
+    const recipients = a.forwardTo
+      .map((r) => r.emailAddress?.address)
+      .join(', ');
+    actions.push(`Forward to: ${recipients}`);
   }
-
-  // Mark importance
-  if (rule.actions?.markImportance) {
-    actions.push(`Mark importance: ${rule.actions.markImportance}`);
+  if (a.forwardAsAttachmentTo?.length > 0) {
+    const recipients = a.forwardAsAttachmentTo
+      .map((r) => r.emailAddress?.address)
+      .join(', ');
+    actions.push(`Forward as attachment to: ${recipients}`);
   }
-
-  // Forward
-  if (rule.actions?.forwardTo?.length > 0) {
-    const recipients = rule.actions.forwardTo
-      .map((r) => r.emailAddress.address)
+  if (a.redirectTo?.length > 0) {
+    const recipients = a.redirectTo
+      .map((r) => r.emailAddress?.address)
       .join(', ');
-    actions.push(`Forward to: ${recipients}`);
+    actions.push(`Redirect to: ${recipients}`);
   }
 
-  // Delete
-  if (rule.actions?.delete === true) {
-    actions.push('Delete');
+  if (a.assignCategories?.length > 0) {
+    actions.push(`Assign categories: ${a.assignCategories.join(', ')}`);
   }
+  if (a.stopProcessingRules === true) actions.push('Stop processing rules');
+  if (a.delete === true) actions.push('Delete (move to Deleted Items)');
+  if (a.permanentDelete === true) actions.push('Permanently delete');
 
   return actions.join('; ');
 }
 
+/**
+ * Format rule exceptions for display
+ * @param {object} rule - Rule object
+ * @returns {string} - Formatted exceptions
+ */
+function formatRuleExceptions(rule) {
+  const parts = [];
+  const e = rule.exceptions;
+  if (!e) return '';
+
+  if (e.fromAddresses?.length > 0) {
+    const senders = e.fromAddresses
+      .map((addr) => addr.emailAddress?.address)
+      .join(', ');
+    parts.push(`From: ${senders}`);
+  }
+  if (e.sentToAddresses?.length > 0) {
+    const recipients = e.sentToAddresses
+      .map((addr) => addr.emailAddress?.address)
+      .join(', ');
+    parts.push(`Sent to: ${recipients}`);
+  }
+  if (e.subjectContains?.length > 0) {
+    parts.push(`Subject contains: "${e.subjectContains.join('", "')}"`);
+  }
+  if (e.bodyContains?.length > 0) {
+    parts.push(`Body contains: "${e.bodyContains.join('", "')}"`);
+  }
+  if (e.bodyOrSubjectContains?.length > 0) {
+    parts.push(
+      `Body/subject contains: "${e.bodyOrSubjectContains.join('", "')}"`
+    );
+  }
+  if (e.senderContains?.length > 0) {
+    parts.push(`Sender contains: "${e.senderContains.join('", "')}"`);
+  }
+  if (e.recipientContains?.length > 0) {
+    parts.push(`Recipient contains: "${e.recipientContains.join('", "')}"`);
+  }
+  if (e.hasAttachment === true) parts.push('Has attachment');
+  if (e.importance) parts.push(`Importance: ${e.importance}`);
+  if (e.sensitivity) parts.push(`Sensitivity: ${e.sensitivity}`);
+  if (e.sentToMe === true) parts.push('Sent to me');
+  if (e.sentOnlyToMe === true) parts.push('Sent only to me');
+  if (e.sentCcMe === true) parts.push('I am in CC');
+  if (e.isAutomaticReply === true) parts.push('Is automatic reply');
+
+  return parts.join('; ');
+}
+
 module.exports = {
   handleListRules,
   getInboxRules,

package/rules/rule-builder.js

@@ -0,0 +1,284 @@
+/**
+ * Shared rule builder utilities for creating and updating mail rules.
+ * Converts flat MCP tool parameters into Microsoft Graph API rule objects.
+ */
+const { getFolderIdByName } = require('../email/folder-utils');
+const { checkRecipientAllowlist } = require('../utils/safety');
+
+const VALID_IMPORTANCE = ['low', 'normal', 'high'];
+const VALID_SENSITIVITY = ['normal', 'personal', 'private', 'confidential'];
+
+/**
+ * Parse a comma-separated string into a trimmed, non-empty array.
+ * @param {string} str - Comma-separated values
+ * @returns {string[]}
+ */
+function parseCommaSeparated(str) {
+  if (!str) return [];
+  return str
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+/**
+ * Convert a comma-separated email string into Graph API recipient objects.
+ * @param {string} emailString - Comma-separated email addresses
+ * @returns {Array<{emailAddress: {address: string}}>}
+ */
+function formatRecipientObjects(emailString) {
+  return parseCommaSeparated(emailString).map((email) => ({
+    emailAddress: { address: email },
+  }));
+}
+
+/**
+ * Build a Graph API conditions object from flat tool parameters.
+ * @param {object} args - Tool arguments
+ * @returns {{ conditions: object, warnings: string[] }}
+ */
+function buildConditions(args) {
+  const conditions = {};
+  const warnings = [];
+
+  // String collections (comma-separated → array with OR logic)
+  if (args.containsSubject) {
+    conditions.subjectContains = parseCommaSeparated(args.containsSubject);
+  }
+  if (args.bodyContains) {
+    conditions.bodyContains = parseCommaSeparated(args.bodyContains);
+  }
+  if (args.bodyOrSubjectContains) {
+    conditions.bodyOrSubjectContains = parseCommaSeparated(
+      args.bodyOrSubjectContains
+    );
+  }
+  if (args.senderContains) {
+    conditions.senderContains = parseCommaSeparated(args.senderContains);
+  }
+  if (args.recipientContains) {
+    conditions.recipientContains = parseCommaSeparated(args.recipientContains);
+  }
+
+  // Recipient collections (comma-separated emails → recipient objects)
+  if (args.fromAddresses) {
+    const recipients = formatRecipientObjects(args.fromAddresses);
+    if (recipients.length > 0) {
+      conditions.fromAddresses = recipients;
+    }
+  }
+  if (args.sentToAddresses) {
+    const recipients = formatRecipientObjects(args.sentToAddresses);
+    if (recipients.length > 0) {
+      conditions.sentToAddresses = recipients;
+    }
+  }
+
+  // Boolean conditions
+  if (args.hasAttachments === true) conditions.hasAttachment = true;
+  if (args.sentToMe === true) conditions.sentToMe = true;
+  if (args.sentOnlyToMe === true) conditions.sentOnlyToMe = true;
+  if (args.sentCcMe === true) conditions.sentCcMe = true;
+  if (args.isAutomaticReply === true) conditions.isAutomaticReply = true;
+
+  // Enum conditions
+  if (args.importance) {
+    if (!VALID_IMPORTANCE.includes(args.importance)) {
+      warnings.push(
+        `Invalid importance "${args.importance}". Must be: ${VALID_IMPORTANCE.join(', ')}`
+      );
+    } else {
+      conditions.importance = args.importance;
+    }
+  }
+  if (args.sensitivity) {
+    if (!VALID_SENSITIVITY.includes(args.sensitivity)) {
+      warnings.push(
+        `Invalid sensitivity "${args.sensitivity}". Must be: ${VALID_SENSITIVITY.join(', ')}`
+      );
+    } else {
+      conditions.sensitivity = args.sensitivity;
+    }
+  }
+
+  return { conditions, warnings };
+}
+
+/**
+ * Build a Graph API actions object from flat tool parameters.
+ * Async because folder resolution requires API calls.
+ * @param {object} args - Tool arguments
+ * @param {string} accessToken - Graph API access token
+ * @returns {Promise<{ actions: object, warnings: string[] }>}
+ */
+async function buildActions(args, accessToken) {
+  const actions = {};
+  const warnings = [];
+
+  // Folder-based actions (name → ID resolution)
+  if (args.moveToFolder) {
+    const folderId = await getFolderIdByName(accessToken, args.moveToFolder);
+    if (!folderId) {
+      warnings.push(`Target folder "${args.moveToFolder}" not found.`);
+    } else {
+      actions.moveToFolder = folderId;
+    }
+  }
+  if (args.copyToFolder) {
+    const folderId = await getFolderIdByName(accessToken, args.copyToFolder);
+    if (!folderId) {
+      warnings.push(`Copy-to folder "${args.copyToFolder}" not found.`);
+    } else {
+      actions.copyToFolder = folderId;
+    }
+  }
+
+  // Boolean actions
+  if (args.markAsRead === true) actions.markAsRead = true;
+  if (args.stopProcessingRules === true) actions.stopProcessingRules = true;
+  if (args.deleteMessage === true) {
+    actions.delete = true;
+    warnings.push('This rule will move matching messages to Deleted Items.');
+  }
+
+  // Enum actions
+  if (args.markImportance) {
+    if (!VALID_IMPORTANCE.includes(args.markImportance)) {
+      warnings.push(
+        `Invalid markImportance "${args.markImportance}". Must be: ${VALID_IMPORTANCE.join(', ')}`
+      );
+    } else {
+      actions.markImportance = args.markImportance;
+    }
+  }
+
+  // Recipient-based actions (comma-separated emails → recipient objects)
+  if (args.forwardTo) {
+    const recipients = formatRecipientObjects(args.forwardTo);
+    if (recipients.length > 0) {
+      // Check allowlist if configured
+      const allowlistError = checkRecipientAllowlist(recipients);
+      if (allowlistError) {
+        warnings.push(
+          `Forward recipients blocked by allowlist: ${args.forwardTo}`
+        );
+      } else {
+        actions.forwardTo = recipients;
+        warnings.push(
+          `This rule will forward all matching emails to: ${args.forwardTo}. Verify these addresses are correct.`
+        );
+      }
+    }
+  }
+  if (args.redirectTo) {
+    const recipients = formatRecipientObjects(args.redirectTo);
+    if (recipients.length > 0) {
+      const allowlistError = checkRecipientAllowlist(recipients);
+      if (allowlistError) {
+        warnings.push(
+          `Redirect recipients blocked by allowlist: ${args.redirectTo}`
+        );
+      } else {
+        actions.redirectTo = recipients;
+        warnings.push(
+          `This rule will redirect all matching emails to: ${args.redirectTo}. The original sender will appear as the sender.`
+        );
+      }
+    }
+  }
+
+  // Category actions
+  if (args.assignCategories) {
+    actions.assignCategories = parseCommaSeparated(args.assignCategories);
+  }
+
+  return { actions, warnings };
+}
+
+/**
+ * Build a Graph API exceptions object from except* prefixed parameters.
+ * @param {object} args - Tool arguments
+ * @returns {{ exceptions: object, warnings: string[] }}
+ */
+function buildExceptions(args) {
+  const exceptions = {};
+  const warnings = [];
+
+  if (args.exceptFromAddresses) {
+    const recipients = formatRecipientObjects(args.exceptFromAddresses);
+    if (recipients.length > 0) {
+      exceptions.fromAddresses = recipients;
+    }
+  }
+  if (args.exceptSubjectContains) {
+    exceptions.subjectContains = parseCommaSeparated(
+      args.exceptSubjectContains
+    );
+  }
+  if (args.exceptSenderContains) {
+    exceptions.senderContains = parseCommaSeparated(args.exceptSenderContains);
+  }
+  if (args.exceptBodyContains) {
+    exceptions.bodyContains = parseCommaSeparated(args.exceptBodyContains);
+  }
+  if (args.exceptHasAttachments === true) {
+    exceptions.hasAttachment = true;
+  }
+
+  return { exceptions, warnings };
+}
+
+/**
+ * Check if any condition was provided in the args.
+ * @param {object} args - Tool arguments
+ * @returns {boolean}
+ */
+function hasAnyCondition(args) {
+  return Boolean(
+    args.fromAddresses ||
+    args.containsSubject ||
+    args.hasAttachments === true ||
+    args.bodyContains ||
+    args.bodyOrSubjectContains ||
+    args.senderContains ||
+    args.recipientContains ||
+    args.sentToAddresses ||
+    args.importance ||
+    args.sensitivity ||
+    args.sentToMe === true ||
+    args.sentOnlyToMe === true ||
+    args.sentCcMe === true ||
+    args.isAutomaticReply === true
+  );
+}
+
+/**
+ * Check if any action was provided in the args.
+ * @param {object} args - Tool arguments
+ * @returns {boolean}
+ */
+function hasAnyAction(args) {
+  return Boolean(
+    args.moveToFolder ||
+    args.copyToFolder ||
+    args.markAsRead === true ||
+    args.markImportance ||
+    args.forwardTo ||
+    args.redirectTo ||
+    args.assignCategories ||
+    args.stopProcessingRules === true ||
+    args.deleteMessage === true
+  );
+}
+
+module.exports = {
+  VALID_IMPORTANCE,
+  VALID_SENSITIVITY,
+  parseCommaSeparated,
+  formatRecipientObjects,
+  buildConditions,
+  buildActions,
+  buildExceptions,
+  hasAnyCondition,
+  hasAnyAction,
+};