@littlebearapps/outlook-assistant 3.6.0 → 3.7.0

package/rules/create.js

@@ -3,8 +3,16 @@
  */
 const { callGraphAPI } = require('../utils/graph-api');
 const { ensureAuthenticated } = require('../auth');
-const { getFolderIdByName } = require('../email/folder-utils');
+const { checkRateLimit } = require('../utils/safety');
+const { formatRuleDryRunPreview } = require('../utils/safety');
 const { getInboxRules } = require('./list');
+const {
+  buildConditions,
+  buildActions,
+  buildExceptions,
+  hasAnyCondition,
+  hasAnyAction,
+} = require('./rule-builder');
 
 /**
  * Create rule handler
@@ -12,18 +20,13 @@ const { getInboxRules } = require('./list');
  * @returns {object} - MCP response
  */
 async function handleCreateRule(args) {
-  const {
-    name,
-    fromAddresses,
-    containsSubject,
-    hasAttachments,
-    moveToFolder,
-    markAsRead,
-    isEnabled = true,
-    sequence,
-  } = args;
+  const { name, isEnabled = true, sequence, dryRun } = args;
 
-  // Add validation for sequence parameter
+  // Rate limit rule creation
+  const rateLimitError = checkRateLimit('manage-rules');
+  if (rateLimitError) return rateLimitError;
+
+  // Validate sequence parameter
   if (sequence !== undefined && (isNaN(sequence) || sequence < 1)) {
     return {
       content: [
@@ -46,202 +49,96 @@ async function handleCreateRule(args) {
     };
   }
 
-  // Validate that at least one condition or action is specified
-  const hasCondition =
-    fromAddresses || containsSubject || hasAttachments === true;
-  const hasAction = moveToFolder || markAsRead === true;
-
-  if (!hasCondition) {
+  if (!hasAnyCondition(args)) {
     return {
       content: [
         {
           type: 'text',
-          text: 'At least one condition is required. Specify fromAddresses, containsSubject, or hasAttachments.',
+          text: 'At least one condition is required. Available conditions: fromAddresses, containsSubject, bodyContains, bodyOrSubjectContains, senderContains, recipientContains, sentToAddresses, hasAttachments, importance, sensitivity, sentToMe, sentOnlyToMe, sentCcMe, isAutomaticReply.',
         },
       ],
     };
   }
 
-  if (!hasAction) {
+  if (!hasAnyAction(args)) {
     return {
       content: [
         {
           type: 'text',
-          text: 'At least one action is required. Specify moveToFolder or markAsRead.',
+          text: 'At least one action is required. Available actions: moveToFolder, copyToFolder, markAsRead, markImportance, forwardTo, redirectTo, assignCategories, stopProcessingRules, deleteMessage.',
         },
       ],
     };
   }
 
   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;
+    // Build rule components
+    const { conditions, warnings: condWarnings } = buildConditions(args);
+    const { actions, warnings: actWarnings } = await buildActions(
+      args,
+      accessToken
+    );
+    const { exceptions, warnings: excWarnings } = buildExceptions(args);
 
-    // 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.";
-    }
+    const allWarnings = [...condWarnings, ...actWarnings, ...excWarnings];
 
-    return {
-      content: [
-        {
-          type: 'text',
-          text: responseText,
-        },
-      ],
-    };
-  } catch (error) {
-    if (error.message === 'Authentication required') {
+    // Check for fatal warnings (folder not found = no valid action)
+    const folderNotFound = actWarnings.some((w) => w.includes('not found'));
+    if (folderNotFound && Object.keys(actions).length === 0) {
       return {
         content: [
           {
             type: 'text',
-            text: "Authentication required. Please use the 'authenticate' tool first.",
+            text: actWarnings.filter((w) => w.includes('not found')).join('\n'),
           },
         ],
       };
     }
 
-    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
+    // Determine sequence
     let ruleSequence = sequence;
     if (!ruleSequence) {
+      ruleSequence = 100;
       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
+      } catch (_sequenceError) {
         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
+    // Build the rule object
     const rule = {
       displayName: name,
       isEnabled: isEnabled === true,
       sequence: ruleSequence,
-      conditions: {},
-      actions: {},
+      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 exceptions if any were specified
+    if (Object.keys(exceptions).length > 0) {
+      rule.exceptions = exceptions;
     }
 
-    // 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}`,
-        };
+    // Dry-run: preview without creating
+    if (dryRun) {
+      const preview = formatRuleDryRunPreview(rule);
+      let text = `DRY RUN — Rule preview (not created):\n\n${preview}`;
+      if (allWarnings.length > 0) {
+        text += `\n\nWarnings:\n${allWarnings.map((w) => `- ${w}`).join('\n')}`;
       }
-    }
-
-    if (markAsRead === true) {
-      rule.actions.markAsRead = true;
+      return {
+        content: [{ type: 'text', text }],
+      };
     }
 
     // Create the rule
@@ -253,20 +150,47 @@ async function createInboxRule(accessToken, ruleOptions) {
     );
 
     if (response && response.id) {
+      let text = `Successfully created rule "${name}" with sequence ${ruleSequence}.`;
+      if (allWarnings.length > 0) {
+        text += `\n\nNotes:\n${allWarnings.map((w) => `- ${w}`).join('\n')}`;
+      }
+      if (!sequence) {
+        text +=
+          "\n\nTip: You can specify a 'sequence' parameter when creating rules to control their execution order. Lower sequence numbers run first.";
+      }
       return {
-        success: true,
-        message: `Successfully created rule "${name}" with sequence ${ruleSequence}.`,
-        ruleId: response.id,
+        content: [{ type: 'text', text }],
       };
-    } else {
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: "Failed to create rule. The server didn't return a rule ID.",
+        },
+      ],
+    };
+  } catch (error) {
+    if (error.message === 'Authentication required') {
       return {
-        success: false,
-        message: "Failed to create rule. The server didn't return a rule ID.",
+        content: [
+          {
+            type: 'text',
+            text: "Authentication required. Please use the 'auth' tool with action=authenticate first.",
+          },
+        ],
       };
     }
-  } catch (error) {
-    console.error(`Error creating rule: ${error.message}`);
-    throw error;
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error creating rule: ${error.message}`,
+        },
+      ],
+    };
   }
 }
 

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,
 };