@littlebearapps/outlook-assistant 3.5.2 → 3.7.0

package/rules/index.js

@@ -3,8 +3,10 @@
  */
 const { handleListRules, getInboxRules } = require('./list');
 const handleCreateRule = require('./create');
+const handleUpdateRule = require('./update');
 const { callGraphAPI } = require('../utils/graph-api');
 const { ensureAuthenticated } = require('../auth');
+const { checkRateLimit } = require('../utils/safety');
 
 /**
  * Delete rule handler
@@ -14,6 +16,10 @@ const { ensureAuthenticated } = require('../auth');
 async function handleDeleteRule(args) {
   const { ruleName, ruleId } = args;
 
+  // Rate limit
+  const rateLimitError = checkRateLimit('manage-rules');
+  if (rateLimitError) return rateLimitError;
+
   if (!ruleName && !ruleId) {
     return {
       content: [
@@ -116,13 +122,9 @@ async function handleEditRuleSequence(args) {
   }
 
   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 {
@@ -135,14 +137,11 @@ async function handleEditRuleSequence(args) {
       };
     }
 
-    // Update the rule sequence
-    const _updateResult = await callGraphAPI(
+    await callGraphAPI(
       accessToken,
       'PATCH',
       `me/mailFolders/inbox/messageRules/${rule.id}`,
-      {
-        sequence: sequence,
-      }
+      { sequence }
     );
 
     return {
@@ -181,7 +180,7 @@ const rulesTools = [
   {
     name: 'manage-rules',
     description:
-      'Manage inbox rules. action=list (default) lists rules. action=create creates a new rule. action=reorder changes rule execution priority. action=delete removes a rule.',
+      'Manage inbox rules. action=list (default) lists rules. action=create creates a new rule with conditions, actions, and optional exceptions. action=update modifies an existing rule. action=reorder changes rule execution priority. action=delete removes a rule.',
     annotations: {
       title: 'Inbox Rules',
       readOnlyHint: false,
@@ -193,59 +192,190 @@ const rulesTools = [
       properties: {
         action: {
           type: 'string',
-          enum: ['list', 'create', 'reorder', 'delete'],
+          enum: ['list', 'create', 'update', 'reorder', 'delete'],
           description: 'Action to perform (default: list)',
         },
-        // list params
+
+        // === List params ===
         includeDetails: {
           type: 'boolean',
           description:
-            'Include detailed rule conditions and actions (action=list)',
+            'Include detailed conditions, actions, and exceptions (action=list)',
         },
-        // create params
+
+        // === Create + Update shared params ===
         name: {
           type: 'string',
-          description: 'Name of the rule to create (action=create, required)',
+          description:
+            'Rule name (action=create required, action=update to rename)',
+        },
+        dryRun: {
+          type: 'boolean',
+          description:
+            'Preview rule without creating/updating (action=create, action=update)',
         },
+        isEnabled: {
+          type: 'boolean',
+          description:
+            'Enable/disable rule (action=create default: true, action=update)',
+        },
+        sequence: {
+          type: 'number',
+          description:
+            'Execution order, lower = higher priority (action=create default: auto, action=reorder required)',
+        },
+
+        // --- Conditions (comma-separated strings become OR arrays) ---
         fromAddresses: {
           type: 'string',
-          description: 'Comma-separated sender email addresses (action=create)',
+          description:
+            'Comma-separated sender emails to match (action=create/update)',
         },
         containsSubject: {
           type: 'string',
-          description: 'Subject text the email must contain (action=create)',
+          description:
+            'Comma-separated subject keywords (OR logic). e.g. "invoice, receipt, payment" (action=create/update)',
+        },
+        bodyContains: {
+          type: 'string',
+          description:
+            'Comma-separated body text keywords (OR logic) (action=create/update)',
+        },
+        bodyOrSubjectContains: {
+          type: 'string',
+          description:
+            'Comma-separated keywords matching body OR subject (OR logic) (action=create/update)',
+        },
+        senderContains: {
+          type: 'string',
+          description:
+            'Comma-separated partial sender matches (action=create/update)',
+        },
+        recipientContains: {
+          type: 'string',
+          description:
+            'Comma-separated partial recipient matches (action=create/update)',
+        },
+        sentToAddresses: {
+          type: 'string',
+          description:
+            'Comma-separated recipient emails to match (action=create/update)',
         },
         hasAttachments: {
           type: 'boolean',
-          description: 'Apply to emails with attachments (action=create)',
+          description: 'Match emails with attachments (action=create/update)',
+        },
+        importance: {
+          type: 'string',
+          enum: ['low', 'normal', 'high'],
+          description:
+            'Match emails with this importance (action=create/update)',
         },
+        sensitivity: {
+          type: 'string',
+          enum: ['normal', 'personal', 'private', 'confidential'],
+          description:
+            'Match emails with this sensitivity (action=create/update)',
+        },
+        sentToMe: {
+          type: 'boolean',
+          description: 'Match emails sent to me (action=create/update)',
+        },
+        sentOnlyToMe: {
+          type: 'boolean',
+          description:
+            'Match emails where I am the only recipient (action=create/update)',
+        },
+        sentCcMe: {
+          type: 'boolean',
+          description: 'Match emails where I am in CC (action=create/update)',
+        },
+        isAutomaticReply: {
+          type: 'boolean',
+          description: 'Match automatic reply emails (action=create/update)',
+        },
+
+        // --- Actions ---
         moveToFolder: {
           type: 'string',
-          description: 'Folder to move matching emails to (action=create)',
+          description:
+            'Folder name to move matching emails to (action=create/update)',
+        },
+        copyToFolder: {
+          type: 'string',
+          description:
+            'Folder name to copy matching emails to (action=create/update)',
         },
         markAsRead: {
           type: 'boolean',
-          description: 'Mark matching emails as read (action=create)',
+          description: 'Mark matching emails as read (action=create/update)',
         },
-        isEnabled: {
+        markImportance: {
+          type: 'string',
+          enum: ['low', 'normal', 'high'],
+          description:
+            'Set importance on matching emails (action=create/update)',
+        },
+        forwardTo: {
+          type: 'string',
+          description:
+            'Comma-separated emails to forward matching messages to (action=create/update)',
+        },
+        redirectTo: {
+          type: 'string',
+          description:
+            'Comma-separated emails to redirect matching messages to (action=create/update)',
+        },
+        assignCategories: {
+          type: 'string',
+          description:
+            'Comma-separated Outlook categories to assign (action=create/update)',
+        },
+        stopProcessingRules: {
           type: 'boolean',
           description:
-            'Enable rule after creation, default: true (action=create)',
+            'Stop evaluating subsequent rules (action=create/update)',
         },
-        sequence: {
-          type: 'number',
+        deleteMessage: {
+          type: 'boolean',
           description:
-            'Execution order, lower numbers run first (action=create default: 100, action=reorder required)',
+            'Move matching emails to Deleted Items (action=create/update)',
         },
-        // reorder params
-        ruleName: {
+
+        // --- Exceptions (rule skipped when these match) ---
+        exceptFromAddresses: {
+          type: 'string',
+          description:
+            'Comma-separated sender emails to exclude (action=create/update)',
+        },
+        exceptSubjectContains: {
+          type: 'string',
+          description:
+            'Comma-separated subject keywords to exclude (action=create/update)',
+        },
+        exceptSenderContains: {
+          type: 'string',
+          description:
+            'Comma-separated partial sender matches to exclude (action=create/update)',
+        },
+        exceptBodyContains: {
           type: 'string',
           description:
-            'Name of the rule (action=reorder required, action=delete alternative to ruleId)',
+            'Comma-separated body keywords to exclude (action=create/update)',
+        },
+        exceptHasAttachments: {
+          type: 'boolean',
+          description: 'Exclude emails with attachments (action=create/update)',
+        },
+
+        // === Update + Reorder + Delete params ===
+        ruleName: {
+          type: 'string',
+          description: 'Name of existing rule (action=update/reorder/delete)',
         },
         ruleId: {
           type: 'string',
-          description: 'ID of the rule to delete (action=delete)',
+          description: 'ID of existing rule (action=update/delete)',
         },
       },
       required: [],
@@ -255,6 +385,8 @@ const rulesTools = [
       switch (action) {
         case 'create':
           return handleCreateRule(args);
+        case 'update':
+          return handleUpdateRule(args);
         case 'reorder':
           return handleEditRuleSequence(args);
         case 'delete':
@@ -271,6 +403,7 @@ module.exports = {
   rulesTools,
   handleListRules,
   handleCreateRule,
+  handleUpdateRule,
   handleEditRuleSequence,
   handleDeleteRule,
 };

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,