@littlebearapps/outlook-assistant 3.6.0 → 3.7.1

package/rules/update.js

@@ -0,0 +1,213 @@
+/**
+ * Update rule functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { checkRateLimit, formatRuleDryRunPreview } = require('../utils/safety');
+const { getInboxRules } = require('./list');
+const {
+  buildConditions,
+  buildActions,
+  buildExceptions,
+} = require('./rule-builder');
+
+/**
+ * Update rule handler — modify an existing rule by name or ID.
+ * Conditions, actions, and exceptions use replace semantics (not merge).
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleUpdateRule(args) {
+  const { ruleName, ruleId, name, isEnabled, sequence, dryRun } = args;
+
+  // Rate limit
+  const rateLimitError = checkRateLimit('manage-rules');
+  if (rateLimitError) return rateLimitError;
+
+  if (!ruleName && !ruleId) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Either ruleName or ruleId is required to identify the rule to update.',
+        },
+      ],
+    };
+  }
+
+  if (sequence !== undefined && (isNaN(sequence) || sequence < 1)) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Sequence must be a positive number greater than zero.',
+        },
+      ],
+    };
+  }
+
+  try {
+    const accessToken = await ensureAuthenticated();
+
+    // Resolve rule ID
+    let resolvedId = ruleId;
+    let currentRule = null;
+
+    const rules = await getInboxRules(accessToken);
+
+    if (resolvedId) {
+      currentRule = rules.find((r) => r.id === resolvedId);
+    } else {
+      currentRule = rules.find((r) => r.displayName === ruleName);
+      if (currentRule) resolvedId = currentRule.id;
+    }
+
+    if (!currentRule) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Rule "${ruleName || ruleId}" not found.`,
+          },
+        ],
+      };
+    }
+
+    // Build PATCH payload — only include fields the user provided
+    const patch = {};
+    const allWarnings = [];
+
+    if (name) patch.displayName = name;
+    if (isEnabled !== undefined) patch.isEnabled = isEnabled;
+    if (sequence) patch.sequence = Math.max(1, Math.floor(sequence));
+
+    // Build conditions if any condition param was provided
+    const { conditions, warnings: condWarnings } = buildConditions(args);
+    if (Object.keys(conditions).length > 0) {
+      patch.conditions = conditions;
+      allWarnings.push(
+        'Conditions replaced (not merged). Use dryRun=true to preview before updating.'
+      );
+    }
+    allWarnings.push(...condWarnings);
+
+    // Build actions if any action param was provided
+    const { actions, warnings: actWarnings } = await buildActions(
+      args,
+      accessToken
+    );
+    if (Object.keys(actions).length > 0) {
+      patch.actions = actions;
+      allWarnings.push(
+        'Actions replaced (not merged). Use dryRun=true to preview before updating.'
+      );
+    }
+    allWarnings.push(...actWarnings);
+
+    // Check for fatal folder-not-found
+    const folderNotFound = actWarnings.some((w) => w.includes('not found'));
+    if (folderNotFound && Object.keys(actions).length === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: actWarnings.filter((w) => w.includes('not found')).join('\n'),
+          },
+        ],
+      };
+    }
+
+    // Build exceptions if any except* param was provided
+    const { exceptions, warnings: excWarnings } = buildExceptions(args);
+    if (Object.keys(exceptions).length > 0) {
+      patch.exceptions = exceptions;
+    }
+    allWarnings.push(...excWarnings);
+
+    // Check that something is actually being changed
+    if (Object.keys(patch).length === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `No changes specified for rule "${currentRule.displayName}". Provide at least one parameter to update (name, isEnabled, sequence, conditions, actions, or exceptions).`,
+          },
+        ],
+      };
+    }
+
+    // Dry-run: show before/after preview
+    if (dryRun) {
+      const updatedRule = { ...currentRule, ...patch };
+      const currentPreview = formatRuleDryRunPreview(currentRule);
+      const updatedPreview = formatRuleDryRunPreview(updatedRule);
+
+      let text = `DRY RUN — Update preview for "${currentRule.displayName}" (not applied):\n\n`;
+      text += `CURRENT:\n${currentPreview}\n\n`;
+      text += `AFTER UPDATE:\n${updatedPreview}`;
+      if (allWarnings.length > 0) {
+        text += `\n\nWarnings:\n${allWarnings.map((w) => `- ${w}`).join('\n')}`;
+      }
+      return {
+        content: [{ type: 'text', text }],
+      };
+    }
+
+    // Execute PATCH
+    await callGraphAPI(
+      accessToken,
+      'PATCH',
+      `me/mailFolders/inbox/messageRules/${resolvedId}`,
+      patch
+    );
+
+    const changedFields = Object.keys(patch)
+      .map((k) => {
+        if (k === 'displayName') return `name → "${patch.displayName}"`;
+        if (k === 'isEnabled') {
+          return patch.isEnabled ? 'enabled' : 'disabled';
+        }
+        if (k === 'sequence') return `sequence → ${patch.sequence}`;
+        if (k === 'conditions') return 'conditions updated';
+        if (k === 'actions') return 'actions updated';
+        if (k === 'exceptions') return 'exceptions updated';
+        return k;
+      })
+      .join(', ');
+
+    let text = `Successfully updated rule "${currentRule.displayName}": ${changedFields}.`;
+    // Filter out the replace/merge info warnings from the response since the update is done
+    const relevantWarnings = allWarnings.filter(
+      (w) => !w.includes('replaced (not merged)')
+    );
+    if (relevantWarnings.length > 0) {
+      text += `\n\nNotes:\n${relevantWarnings.map((w) => `- ${w}`).join('\n')}`;
+    }
+
+    return {
+      content: [{ type: 'text', text }],
+    };
+  } catch (error) {
+    if (error.message === 'Authentication required') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: "Authentication required. Please use the 'auth' tool with action=authenticate first.",
+          },
+        ],
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error updating rule: ${error.message}`,
+        },
+      ],
+    };
+  }
+}
+
+module.exports = handleUpdateRule;

package/settings/index.js

@@ -56,13 +56,7 @@ function formatAutomaticReplies(settings) {
 
   const lines = [];
   lines.push(
-    `**Status**: ${
-      settings.status === 'disabled'
-        ? '🔴 Disabled'
-        : settings.status === 'alwaysEnabled'
-          ? '🟢 Always Enabled'
-          : '📅 Scheduled'
-    }`
+    `**Status**: ${{ disabled: '🔴 Disabled', alwaysEnabled: '🟢 Always Enabled' }[settings.status] || '📅 Scheduled'}`
   );
 
   if (settings.status !== 'disabled') {
@@ -113,7 +107,7 @@ async function handleGetMailboxSettings(args) {
 
     const settings = await callGraphAPI(accessToken, 'GET', endpoint);
 
-    let output = [];
+    const output = [];
     output.push('# Mailbox Settings\n');
 
     if (section && section !== 'all') {
@@ -287,7 +281,7 @@ async function handleSetAutomaticReplies(args) {
       'me/mailboxSettings/automaticRepliesSetting'
     );
 
-    let output = [];
+    const output = [];
     output.push('Automatic replies updated!\n');
     output.push(formatAutomaticReplies(updated));
 
@@ -413,17 +407,11 @@ async function handleSetWorkingHours(args) {
     );
 
     // Build update
+    const padTime = (t) =>
+      t.length === 5 ? `${t}:00.0000000` : `${t}.0000000`;
     const workingHours = {
-      startTime: startTime
-        ? startTime.length === 5
-          ? startTime + ':00.0000000'
-          : startTime + '.0000000'
-        : current.startTime,
-      endTime: endTime
-        ? endTime.length === 5
-          ? endTime + ':00.0000000'
-          : endTime + '.0000000'
-        : current.endTime,
+      startTime: startTime ? padTime(startTime) : current.startTime,
+      endTime: endTime ? padTime(endTime) : current.endTime,
       daysOfWeek: daysOfWeek
         ? daysOfWeek.map((d) => d.toLowerCase())
         : current.daysOfWeek,
@@ -442,7 +430,7 @@ async function handleSetWorkingHours(args) {
       'me/mailboxSettings/workingHours'
     );
 
-    let output = [];
+    const output = [];
     output.push('Working hours updated!\n');
     output.push(formatWorkingHours(updated));
 
@@ -491,7 +479,7 @@ async function handleGetAutomaticReplies() {
       'me/mailboxSettings/automaticRepliesSetting'
     );
 
-    let output = [];
+    const output = [];
     output.push('# Automatic Replies\n');
     output.push(formatAutomaticReplies(settings));
 
@@ -533,7 +521,7 @@ async function handleGetWorkingHours() {
       'me/mailboxSettings/workingHours'
     );
 
-    let output = [];
+    const output = [];
     output.push('# Working Hours\n');
     output.push(formatWorkingHours(settings));
 

package/utils/graph-api.js

@@ -72,7 +72,7 @@ async function callGraphAPI(
         }
 
         if (queryString) {
-          queryString = '?' + queryString;
+          queryString = `?${queryString}`;
         }
       }
 

package/utils/response-formatter.js

@@ -187,7 +187,7 @@ function formatEmailListAsTable(emails, folder, meta = {}) {
     const date = formatDateShort(email.receivedDateTime);
     const status = email.isRead ? '📖' : '📬';
     const subject = truncateText(email.subject || '(no subject)', 40);
-    const shortId = email.id.substring(0, 20) + '...';
+    const shortId = `${email.id.substring(0, 20)}...`;
 
     output += `| ${i + 1} | ${status} | ${date} | ${truncateText(from, 20)} | ${subject} | \`${shortId}\` |\n`;
   });
@@ -237,10 +237,12 @@ function formatEmailContent(
 
   if (verbosity === VERBOSITY.FULL) {
     output += `\n**ID:** \`${email.id}\``;
-    if (email.conversationId)
+    if (email.conversationId) {
       output += `\n**Conversation ID:** \`${email.conversationId}\``;
-    if (email.internetMessageId)
+    }
+    if (email.internetMessageId) {
       output += `\n**Message-ID:** \`${email.internetMessageId}\``;
+    }
   }
 
   output += '\n\n---\n\n';
@@ -457,7 +459,7 @@ function formatRecipients(recipients) {
 function truncateText(text, maxLength) {
   if (!text) return '';
   if (text.length <= maxLength) return text;
-  return text.substring(0, maxLength - 3) + '...';
+  return `${text.substring(0, maxLength - 3)}...`;
 }
 
 /**
@@ -490,10 +492,10 @@ function escapeCSV(value) {
   const isFormula = formulaChars.some((ch) => str.startsWith(ch));
 
   if (isFormula) {
-    return '"' + "'" + str.replace(/"/g, '""') + '"';
+    return `"` + `'${str.replace(/"/g, '""')}"`;
   }
   if (needsQuoting) {
-    return '"' + str.replace(/"/g, '""') + '"';
+    return `"${str.replace(/"/g, '""')}"`;
   }
   return str;
 }

package/utils/safety.js

@@ -116,8 +116,121 @@ function formatDryRunPreview(emailObject) {
   };
 }
 
+/**
+ * Format a dry-run preview for a mail rule (create or update).
+ * @param {object} rule - The composed Graph API rule object
+ * @returns {string} - Human-readable rule preview text
+ */
+function formatRuleDryRunPreview(rule) {
+  const lines = [];
+
+  lines.push(`Name: ${rule.displayName}`);
+  lines.push(`Enabled: ${rule.isEnabled !== false}`);
+  if (rule.sequence) lines.push(`Sequence: ${rule.sequence}`);
+
+  // Conditions
+  const cond = rule.conditions || {};
+  const condParts = [];
+  if (cond.fromAddresses?.length > 0) {
+    condParts.push(
+      `From: ${cond.fromAddresses.map((a) => a.emailAddress?.address).join(', ')}`
+    );
+  }
+  if (cond.subjectContains?.length > 0) {
+    condParts.push(
+      `Subject contains (any): "${cond.subjectContains.join('", "')}"`
+    );
+  }
+  if (cond.bodyContains?.length > 0) {
+    condParts.push(`Body contains (any): "${cond.bodyContains.join('", "')}"`);
+  }
+  if (cond.bodyOrSubjectContains?.length > 0) {
+    condParts.push(
+      `Body or subject contains (any): "${cond.bodyOrSubjectContains.join('", "')}"`
+    );
+  }
+  if (cond.senderContains?.length > 0) {
+    condParts.push(
+      `Sender contains (any): "${cond.senderContains.join('", "')}"`
+    );
+  }
+  if (cond.recipientContains?.length > 0) {
+    condParts.push(
+      `Recipient contains (any): "${cond.recipientContains.join('", "')}"`
+    );
+  }
+  if (cond.sentToAddresses?.length > 0) {
+    condParts.push(
+      `Sent to: ${cond.sentToAddresses.map((a) => a.emailAddress?.address).join(', ')}`
+    );
+  }
+  if (cond.hasAttachment === true) condParts.push('Has attachment');
+  if (cond.importance) condParts.push(`Importance: ${cond.importance}`);
+  if (cond.sensitivity) condParts.push(`Sensitivity: ${cond.sensitivity}`);
+  if (cond.sentToMe === true) condParts.push('Sent to me');
+  if (cond.sentOnlyToMe === true) condParts.push('Sent only to me');
+  if (cond.sentCcMe === true) condParts.push('I am in CC');
+  if (cond.isAutomaticReply === true) condParts.push('Is automatic reply');
+  if (condParts.length > 0) {
+    lines.push(`Conditions: ${condParts.join('; ')}`);
+  }
+
+  // Actions
+  const act = rule.actions || {};
+  const actParts = [];
+  if (act.moveToFolder) actParts.push(`Move to folder: ${act.moveToFolder}`);
+  if (act.copyToFolder) actParts.push(`Copy to folder: ${act.copyToFolder}`);
+  if (act.markAsRead === true) actParts.push('Mark as read');
+  if (act.markImportance) {
+    actParts.push(`Mark importance: ${act.markImportance}`);
+  }
+  if (act.forwardTo?.length > 0) {
+    actParts.push(
+      `Forward to: ${act.forwardTo.map((r) => r.emailAddress?.address).join(', ')}`
+    );
+  }
+  if (act.redirectTo?.length > 0) {
+    actParts.push(
+      `Redirect to: ${act.redirectTo.map((r) => r.emailAddress?.address).join(', ')}`
+    );
+  }
+  if (act.assignCategories?.length > 0) {
+    actParts.push(`Assign categories: ${act.assignCategories.join(', ')}`);
+  }
+  if (act.stopProcessingRules === true) actParts.push('Stop processing rules');
+  if (act.delete === true) actParts.push('Delete (move to Deleted Items)');
+  if (actParts.length > 0) {
+    lines.push(`Actions: ${actParts.join('; ')}`);
+  }
+
+  // Exceptions
+  const exc = rule.exceptions || {};
+  const excParts = [];
+  if (exc.fromAddresses?.length > 0) {
+    excParts.push(
+      `From: ${exc.fromAddresses.map((a) => a.emailAddress?.address).join(', ')}`
+    );
+  }
+  if (exc.subjectContains?.length > 0) {
+    excParts.push(`Subject contains: "${exc.subjectContains.join('", "')}"`);
+  }
+  if (exc.senderContains?.length > 0) {
+    excParts.push(`Sender contains: "${exc.senderContains.join('", "')}"`);
+  }
+  if (exc.bodyContains?.length > 0) {
+    excParts.push(`Body contains: "${exc.bodyContains.join('", "')}"`);
+  }
+  if (exc.hasAttachment === true) excParts.push('Has attachment');
+  if (excParts.length > 0) {
+    lines.push(`Exceptions (rule skipped when): ${excParts.join('; ')}`);
+  }
+
+  return lines.join('\n');
+}
+
 module.exports = {
   checkRateLimit,
   checkRecipientAllowlist,
   formatDryRunPreview,
+  formatRuleDryRunPreview,
 };