outlook-cli 1.2.0

package/rules/index.js

@@ -0,0 +1,177 @@
+/**
+ * Email rules management module for Outlook MCP server
+ */
+const handleListRules = require('./list');
+const handleCreateRule = require('./create');
+const { ensureAuthenticated } = require('../auth');
+const { callGraphAPI } = require('../utils/graph-api');
+
+// 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
+};

package/tool-registry.js

@@ -0,0 +1,54 @@
+/**
+ * Shared tool registry used by both the MCP transport and local CLI.
+ */
+const { authTools } = require('./auth');
+const { calendarTools } = require('./calendar');
+const { emailTools } = require('./email');
+const { folderTools } = require('./folder');
+const { rulesTools } = require('./rules');
+
+const TOOLS = Object.freeze([
+  ...authTools,
+  ...calendarTools,
+  ...emailTools,
+  ...folderTools,
+  ...rulesTools
+]);
+
+const TOOL_MAP = new Map(TOOLS.map((tool) => [tool.name, tool]));
+
+function getTools() {
+  return TOOLS;
+}
+
+function listTools() {
+  return TOOLS.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+}
+
+function getTool(name) {
+  return TOOL_MAP.get(name);
+}
+
+async function invokeTool(name, args = {}) {
+  const tool = getTool(name);
+
+  if (!tool || typeof tool.handler !== 'function') {
+    const error = new Error(`Tool not found: ${name}`);
+    error.code = 'TOOL_NOT_FOUND';
+    throw error;
+  }
+
+  return tool.handler(args);
+}
+
+module.exports = {
+  TOOLS,
+  getTools,
+  listTools,
+  getTool,
+  invokeTool
+};

package/utils/graph-api.js

@@ -0,0 +1,120 @@
+/**
+ * Microsoft Graph API helper functions
+ */
+const https = require('https');
+const config = require('../config');
+const mockData = require('./mock-data');
+
+/**
+ * Makes a request to the Microsoft Graph API
+ * @param {string} accessToken - The access token for authentication
+ * @param {string} method - HTTP method (GET, POST, etc.)
+ * @param {string} path - API endpoint path
+ * @param {object} data - Data to send for POST/PUT requests
+ * @param {object} queryParams - Query parameters
+ * @returns {Promise<object>} - The API response
+ */
+async function callGraphAPI(accessToken, method, path, data = null, queryParams = {}) {
+  // For test tokens, we'll simulate the API call
+  if (config.USE_TEST_MODE && accessToken.startsWith('test_access_token_')) {
+    console.error(`TEST MODE: Simulating ${method} ${path} API call`);
+    return mockData.simulateGraphAPIResponse(method, path, data, queryParams);
+  }
+
+  try {
+    console.error(`Making real API call: ${method} ${path}`);
+    
+    // Encode path segments properly
+    const encodedPath = path.split('/')
+      .map(segment => encodeURIComponent(segment))
+      .join('/');
+    
+    // Build query string from parameters with special handling for OData filters
+    let queryString = '';
+    if (Object.keys(queryParams).length > 0) {
+      // Handle $filter parameter specially to ensure proper URI encoding
+      const filter = queryParams.$filter;
+      if (filter) {
+        delete queryParams.$filter; // Remove from regular params
+      }
+      
+      // Build query string with proper encoding for regular params
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(queryParams)) {
+        params.append(key, value);
+      }
+      
+      queryString = params.toString();
+      
+      // Add filter parameter separately with proper encoding
+      if (filter) {
+        if (queryString) {
+          queryString += `&$filter=${encodeURIComponent(filter)}`;
+        } else {
+          queryString = `$filter=${encodeURIComponent(filter)}`;
+        }
+      }
+      
+      if (queryString) {
+        queryString = '?' + queryString;
+      }
+      
+      console.error(`Query string: ${queryString}`);
+    }
+    
+    const url = `${config.GRAPH_API_ENDPOINT}${encodedPath}${queryString}`;
+    console.error(`Full URL: ${url}`);
+    
+    return new Promise((resolve, reject) => {
+      const options = {
+        method: method,
+        headers: {
+          'Authorization': `Bearer ${accessToken}`,
+          'Content-Type': 'application/json'
+        }
+      };
+      
+      const req = https.request(url, options, (res) => {
+        let responseData = '';
+        
+        res.on('data', (chunk) => {
+          responseData += chunk;
+        });
+        
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              responseData = responseData ? responseData : '{}';
+              const jsonResponse = JSON.parse(responseData);
+              resolve(jsonResponse);
+            } catch (error) {
+              reject(new Error(`Error parsing API response: ${error.message}`));
+            }
+          } else if (res.statusCode === 401) {
+            // Token expired or invalid
+            reject(new Error('UNAUTHORIZED'));
+          } else {
+            reject(new Error(`API call failed with status ${res.statusCode}: ${responseData}`));
+          }
+        });
+      });
+      
+      req.on('error', (error) => {
+        reject(new Error(`Network error during API call: ${error.message}`));
+      });
+      
+      if (data && (method === 'POST' || method === 'PATCH' || method === 'PUT')) {
+        req.write(JSON.stringify(data));
+      }
+      
+      req.end();
+    });
+  } catch (error) {
+    console.error('Error calling Graph API:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  callGraphAPI
+};

package/utils/mock-data.js

@@ -0,0 +1,145 @@
+/**
+ * Mock data functions for test mode
+ */
+
+/**
+ * Simulates Microsoft Graph API responses for testing
+ * @param {string} method - HTTP method
+ * @param {string} path - API path
+ * @param {object} data - Request data
+ * @param {object} queryParams - Query parameters
+ * @returns {object} - Simulated API response
+ */
+function simulateGraphAPIResponse(method, path, data, queryParams) {
+  console.error(`Simulating response for: ${method} ${path}`);
+  
+  if (method === 'GET') {
+    if (path.includes('messages') && !path.includes('sendMail')) {
+      // Simulate a successful email list/search response
+      if (path.includes('/messages/')) {
+        // Single email response
+        return {
+          id: "simulated-email-id",
+          subject: "Simulated Email Subject",
+          from: {
+            emailAddress: {
+              name: "Simulated Sender",
+              address: "sender@example.com"
+            }
+          },
+          toRecipients: [{
+            emailAddress: {
+              name: "Recipient Name",
+              address: "recipient@example.com"
+            }
+          }],
+          ccRecipients: [],
+          bccRecipients: [],
+          receivedDateTime: new Date().toISOString(),
+          bodyPreview: "This is a simulated email preview...",
+          body: {
+            contentType: "text",
+            content: "This is the full content of the simulated email. Since we can't connect to the real Microsoft Graph API, we're returning this placeholder content instead."
+          },
+          hasAttachments: false,
+          importance: "normal",
+          isRead: false,
+          internetMessageHeaders: []
+        };
+      } else {
+        // Email list response
+        return {
+          value: [
+            {
+              id: "simulated-email-1",
+              subject: "Important Meeting Tomorrow",
+              from: {
+                emailAddress: {
+                  name: "John Doe",
+                  address: "john@example.com"
+                }
+              },
+              toRecipients: [{
+                emailAddress: {
+                  name: "You",
+                  address: "you@example.com"
+                }
+              }],
+              ccRecipients: [],
+              receivedDateTime: new Date().toISOString(),
+              bodyPreview: "Let's discuss the project status...",
+              hasAttachments: false,
+              importance: "high",
+              isRead: false
+            },
+            {
+              id: "simulated-email-2",
+              subject: "Weekly Report",
+              from: {
+                emailAddress: {
+                  name: "Jane Smith",
+                  address: "jane@example.com"
+                }
+              },
+              toRecipients: [{
+                emailAddress: {
+                  name: "You",
+                  address: "you@example.com"
+                }
+              }],
+              ccRecipients: [],
+              receivedDateTime: new Date(Date.now() - 86400000).toISOString(), // Yesterday
+              bodyPreview: "Please find attached the weekly report...",
+              hasAttachments: true,
+              importance: "normal",
+              isRead: true
+            },
+            {
+              id: "simulated-email-3",
+              subject: "Question about the project",
+              from: {
+                emailAddress: {
+                  name: "Bob Johnson",
+                  address: "bob@example.com"
+                }
+              },
+              toRecipients: [{
+                emailAddress: {
+                  name: "You",
+                  address: "you@example.com"
+                }
+              }],
+              ccRecipients: [],
+              receivedDateTime: new Date(Date.now() - 172800000).toISOString(), // 2 days ago
+              bodyPreview: "I had a question about the timeline...",
+              hasAttachments: false,
+              importance: "normal",
+              isRead: false
+            }
+          ]
+        };
+      }
+    } else if (path.includes('mailFolders')) {
+      // Simulate a mail folders response
+      return {
+        value: [
+          { id: "inbox", displayName: "Inbox" },
+          { id: "drafts", displayName: "Drafts" },
+          { id: "sentItems", displayName: "Sent Items" },
+          { id: "deleteditems", displayName: "Deleted Items" }
+        ]
+      };
+    }
+  } else if (method === 'POST' && path.includes('sendMail')) {
+    // Simulate a successful email send
+    return {};
+  }
+  
+  // If we get here, we don't have a simulation for this endpoint
+  console.error(`No simulation available for: ${method} ${path}`);
+  return {};
+}
+
+module.exports = {
+  simulateGraphAPIResponse
+};