@tgai96/outlook-mcp 1.0.0

package/calendar/cancel.js

@@ -0,0 +1,64 @@
+/**
+ * Cancel event functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * Cancel event handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleCancelEvent(args) {
+  const { eventId, comment } = args;
+
+  if (!eventId) {
+    return {
+      content: [{
+        type: "text",
+        text: "Event ID is required to cancel an event."
+      }]
+    };
+  }
+
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+
+    // Build API endpoint
+    const endpoint = `me/events/${eventId}/cancel`;
+
+    // Request body
+    const body = {
+      comment: comment || "Cancelled via API"
+    };
+
+    // Make API call
+    await callGraphAPI(accessToken, 'POST', endpoint, body);
+
+    return {
+      content: [{
+        type: "text",
+        text: `Event with ID ${eventId} has been successfully cancelled.`
+      }]
+    };
+  } 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 cancelling event: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleCancelEvent;

package/calendar/create.js

@@ -0,0 +1,69 @@
+/**
+ * Create event functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { DEFAULT_TIMEZONE } = require('../config');
+
+/**
+ * Create event handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleCreateEvent(args) {
+  const { subject, start, end, attendees, body } = args;
+
+  if (!subject || !start || !end) {
+    return {
+      content: [{
+        type: "text",
+        text: "Subject, start, and end times are required to create an event."
+      }]
+    };
+  }
+
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+
+    // Build API endpoint
+    const endpoint = `me/events`;
+
+    // Request body
+    const bodyContent = {
+      subject,
+      start: { dateTime: start.dateTime || start, timeZone: start.timeZone || DEFAULT_TIMEZONE },
+      end: { dateTime: end.dateTime || end, timeZone: end.timeZone || DEFAULT_TIMEZONE },
+      attendees: attendees?.map(email => ({ emailAddress: { address: email }, type: "required" })),
+      body: { contentType: "HTML", content: body || "" }
+    };
+
+    // Make API call
+    const response = await callGraphAPI(accessToken, 'POST', endpoint, bodyContent);
+
+    return {
+      content: [{
+        type: "text",
+        text: `Event '${subject}' has been successfully created.`
+      }]
+    };
+  } 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 creating event: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleCreateEvent;

package/calendar/decline.js

@@ -0,0 +1,64 @@
+/**
+ * Decline event functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * Decline event handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleDeclineEvent(args) {
+  const { eventId, comment } = args;
+
+  if (!eventId) {
+    return {
+      content: [{
+        type: "text",
+        text: "Event ID is required to decline an event."
+      }]
+    };
+  }
+
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+
+    // Build API endpoint
+    const endpoint = `me/events/${eventId}/decline`;
+
+    // Request body
+    const body = {
+      comment: comment || "Declined via API"
+    };
+
+    // Make API call
+    await callGraphAPI(accessToken, 'POST', endpoint, body);
+
+    return {
+      content: [{
+        type: "text",
+        text: `Event with ID ${eventId} has been successfully declined.`
+      }]
+    };
+  } 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 declining event: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleDeclineEvent;

package/calendar/delete.js

@@ -0,0 +1,59 @@
+/**
+ * Delete event functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * Delete event handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleDeleteEvent(args) {
+  const { eventId } = args;
+
+  if (!eventId) {
+    return {
+      content: [{
+        type: "text",
+        text: "Event ID is required to delete an event."
+      }]
+    };
+  }
+
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+
+    // Build API endpoint
+    const endpoint = `me/events/${eventId}`;
+
+    // Make API call
+    await callGraphAPI(accessToken, 'DELETE', endpoint);
+
+    return {
+      content: [{
+        type: "text",
+        text: `Event with ID ${eventId} has been successfully deleted.`
+      }]
+    };
+  } 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 deleting event: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleDeleteEvent;

package/calendar/index.js

@@ -0,0 +1,123 @@
+/**
+ * Calendar module for Outlook MCP server
+ */
+const handleListEvents = require('./list');
+const handleDeclineEvent = require('./decline');
+const handleCreateEvent = require('./create');
+const handleCancelEvent = require('./cancel');
+const handleDeleteEvent = require('./delete');
+
+// Calendar tool definitions
+const calendarTools = [
+  {
+    name: "list-events",
+    description: "Lists upcoming events from your calendar",
+    inputSchema: {
+      type: "object",
+      properties: {
+        count: {
+          type: "number",
+          description: "Number of events to retrieve (default: 10, max: 50)"
+        }
+      },
+      required: []
+    },
+    handler: handleListEvents
+  },
+  {
+    name: "decline-event",
+    description: "Declines a calendar event",
+    inputSchema: {
+      type: "object",
+      properties: {
+        eventId: {
+          type: "string",
+          description: "The ID of the event to decline"
+        },
+        comment: {
+          type: "string",
+          description: "Optional comment for declining the event"
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: handleDeclineEvent
+  },
+  {
+    name: "create-event",
+    description: "Creates a new calendar event",
+    inputSchema: {
+      type: "object",
+      properties: {
+        subject: {
+          type: "string",
+          description: "The subject of the event"
+        },
+        start: {
+          type: "string",
+          description: "The start time of the event in ISO 8601 format"
+        },
+        end: {
+          type: "string",
+          description: "The end time of the event in ISO 8601 format"
+        },
+        attendees: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "List of attendee email addresses"
+        },
+        body: {
+          type: "string",
+          description: "Optional body content for the event"
+        }
+      },
+      required: ["subject", "start", "end"]
+    },
+    handler: handleCreateEvent
+  },
+  {
+    name: "cancel-event",
+    description: "Cancels a calendar event",
+    inputSchema: {
+      type: "object",
+      properties: {
+        eventId: {
+          type: "string",
+          description: "The ID of the event to cancel"
+        },
+        comment: {
+          type: "string",
+          description: "Optional comment for cancelling the event"
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: handleCancelEvent
+  },
+  {
+    name: "delete-event",
+    description: "Deletes a calendar event",
+    inputSchema: {
+      type: "object",
+      properties: {
+        eventId: {
+          type: "string",
+          description: "The ID of the event to delete"
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: handleDeleteEvent
+  }
+];
+
+module.exports = {
+  calendarTools,
+  handleListEvents,
+  handleDeclineEvent,
+  handleCreateEvent,
+  handleCancelEvent,
+  handleDeleteEvent
+};

package/calendar/list.js

@@ -0,0 +1,77 @@
+/**
+ * List events functionality
+ */
+const config = require('../config');
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+
+/**
+ * List events handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleListEvents(args) {
+  const count = Math.min(args.count || 10, config.MAX_RESULT_COUNT);
+  
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+    
+    // Build API endpoint
+    let endpoint = 'me/events';
+    
+    // Add query parameters
+    const queryParams = {
+      $top: count,
+      $orderby: 'start/dateTime',
+      $filter: `start/dateTime ge '${new Date().toISOString()}'`,
+      $select: config.CALENDAR_SELECT_FIELDS
+    };
+    
+    // Make API call
+    const response = await callGraphAPI(accessToken, 'GET', endpoint, null, queryParams);
+    
+    if (!response.value || response.value.length === 0) {
+      return {
+        content: [{ 
+          type: "text", 
+          text: "No calendar events found."
+        }]
+      };
+    }
+    
+    // Format results
+    const eventList = response.value.map((event, index) => {
+      const startDate = new Date(event.start.dateTime).toLocaleString(event.start.timeZone);
+      const endDate = new Date(event.end.dateTime).toLocaleString(event.end.timeZone);
+      const location = event.location.displayName || 'No location';
+      
+      return `${index + 1}. ${event.subject} - Location: ${location}\nStart: ${startDate}\nEnd: ${endDate}\nSubject: ${event.subject}\nSummary: ${event.bodyPreview}\nID: ${event.id}\n`;
+    }).join("\n");
+    
+    return {
+      content: [{ 
+        type: "text", 
+        text: `Found ${response.value.length} events:\n\n${eventList}`
+      }]
+    };
+  } 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 events: ${error.message}`
+      }]
+    };
+  }
+}
+
+module.exports = handleListEvents;

package/cli.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for outlook-mcp package
+ * 
+ * Usage:
+ *   npx outlook-mcp              - Start MCP server (default)
+ *   npx outlook-mcp auth         - Start authentication server
+ *   npx outlook-mcp --help       - Show help
+ */
+
+const { spawn, exec } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+// Load environment variables from .env file if it exists
+require('dotenv').config();
+
+// Load config utilities
+const config = require('./config');
+
+const command = process.argv[2];
+
+// Show help if --help flag
+if (command === '--help' || command === '-h') {
+  console.log(`
+Outlook MCP Server
+
+Usage:
+  npx outlook-mcp              Start the MCP server (default)
+  npx outlook-mcp auth         Start the authentication server
+  npx outlook-mcp config       Configure Azure credentials interactively
+  npx outlook-mcp test-all-tools  Test all MCP tools with your stored tokens
+  npx outlook-mcp --help       Show this help message
+
+Examples:
+  # Start MCP server
+  npx outlook-mcp
+  
+  # Configure credentials (first time setup)
+  npx outlook-mcp config
+  
+  # Authenticate with Microsoft
+  npx outlook-mcp auth
+  
+  # Test all tools (requires authentication first)
+  npx outlook-mcp test-all-tools
+  
+  This will start a local server on port 3333 and automatically open your browser
+  to authenticate with Microsoft. After successful authentication, tokens will be
+  saved to:
+  - macOS/Linux: ~/.outlook-mcp/tokens.json
+  - Windows: %USERPROFILE%\\.outlook-mcp\\tokens.json
+
+Environment Variables:
+  MS_CLIENT_ID              Your Microsoft Azure app client ID (required for auth - PKCE flow)
+  MS_CLIENT_SECRET          Your Microsoft Azure app client secret (required for MCP server)
+
+`);
+  process.exit(0);
+}
+
+// Function to open browser cross-platform
+function openBrowser(url) {
+  const platform = os.platform();
+  let command;
+  
+  switch (platform) {
+    case 'darwin': // macOS
+      command = `open "${url}"`;
+      break;
+    case 'win32': // Windows
+      command = `start "" "${url}"`;
+      break;
+    default: // Linux and others
+      command = `xdg-open "${url}"`;
+      break;
+  }
+  
+  exec(command, (error) => {
+    if (error) {
+      // Browser opening failed, but that's okay - user can manually open
+      console.log(`\n⚠️  Could not automatically open browser. Please visit:\n   ${url}\n`);
+    }
+  });
+}
+
+// Handle config command
+if (command === 'config') {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  console.log('📝 Outlook MCP Configuration Setup\n');
+  const configHomeDir = process.env.HOME || process.env.USERPROFILE || os.homedir() || '/tmp';
+  const configPath = path.join(configHomeDir, '.outlook-mcp', 'config.json');
+  console.log(`This will save your Azure credentials to ${configPath}\n`);
+  console.log('Note: Authentication uses PKCE (no client_secret needed for auth),');
+  console.log('      but MS_CLIENT_SECRET is required for MCP server operations.\n');
+  
+  rl.question('Enter MS_CLIENT_ID: ', (clientId) => {
+    if (!clientId || !clientId.trim()) {
+      console.error('\n❌ Client ID is required.');
+      rl.close();
+      process.exit(1);
+    }
+    
+    rl.question('Enter MS_CLIENT_SECRET (required for MCP server): ', (clientSecret) => {
+      if (!clientSecret || !clientSecret.trim()) {
+        console.error('\n❌ Client Secret is required for MCP server operations.');
+        rl.close();
+        process.exit(1);
+      }
+      
+      rl.question('Use test mode? (true/false, default: false): ', (useTestMode) => {
+        const configData = {
+          MS_CLIENT_ID: clientId.trim(),
+          MS_CLIENT_SECRET: clientSecret.trim(),
+          USE_TEST_MODE: useTestMode.trim().toLowerCase() === 'true' || false
+        };
+        
+        if (config.saveConfig(configData)) {
+          console.log(`\n✅ Configuration saved to ${configPath}`);
+          console.log('   You can now use npx outlook-mcp without environment variables!');
+        } else {
+          console.error('\n❌ Failed to save configuration.');
+          rl.close();
+          process.exit(1);
+        }
+        
+        rl.close();
+      });
+    });
+  });
+} else if (command === 'auth') {
+  console.log('🚀 Starting Outlook MCP Authentication Server...\n');
+  
+  // Check if MS_CLIENT_ID is set (from env or config file)
+  const loadedConfig = config.loadConfig();
+  const clientId = process.env.MS_CLIENT_ID || loadedConfig.MS_CLIENT_ID;
+  
+  if (!clientId) {
+    console.error('⚠️  Warning: MS_CLIENT_ID is not set.');
+    console.error('   Please set it using one of these methods:\n');
+    console.error('   1. Run: npx outlook-mcp config');
+    console.error('   2. Export: export MS_CLIENT_ID=your-client-id-here');
+    const configPath = path.join(process.env.HOME || process.env.USERPROFILE || os.homedir() || '/tmp', '.outlook-mcp', 'config.json');
+    console.error(`   3. Create ${configPath} with MS_CLIENT_ID`);
+    console.error('   4. Create .env file with MS_CLIENT_ID=your-client-id-here\n');
+    process.exit(1);
+  }
+  
+  // Start the auth server
+  const authServerPath = path.join(__dirname, 'outlook-auth-server.js');
+  const child = spawn('node', [authServerPath], {
+    stdio: 'inherit',
+    env: process.env
+  });
+  
+  // Wait for server to start, then open browser
+  const authUrl = 'http://localhost:3333/auth';
+  
+  // Function to check if server is ready and open browser
+  function checkServerAndOpenBrowser() {
+    const http = require('http');
+    const checkRequest = http.get('http://localhost:3333/', (res) => {
+      // Server is ready, open browser
+      console.log(`\n🌐 Opening browser to: ${authUrl}\n`);
+      openBrowser(authUrl);
+    });
+    
+    checkRequest.on('error', () => {
+      // Server not ready yet, try again in 500ms
+      setTimeout(checkServerAndOpenBrowser, 500);
+    });
+  }
+  
+  // Start checking after a short delay
+  setTimeout(checkServerAndOpenBrowser, 1000);
+  
+  // Handle process termination
+  process.on('SIGINT', () => {
+    console.log('\n\nShutting down authentication server...');
+    child.kill('SIGINT');
+    process.exit(0);
+  });
+  
+  process.on('SIGTERM', () => {
+    child.kill('SIGTERM');
+    process.exit(0);
+  });
+  
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+  
+  child.on('error', (error) => {
+    console.error('Error starting authentication server:', error.message);
+    process.exit(1);
+  });
+} else if (command === 'test-all-tools') {
+  // Run the test suite
+  const testScriptPath = path.join(__dirname, 'test-mcp-tools.js');
+  const child = spawn('node', [testScriptPath], {
+    stdio: 'inherit',
+    env: process.env
+  });
+  
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+  
+  child.on('error', (error) => {
+    console.error('Error running test suite:', error.message);
+    process.exit(1);
+  });
+} else {
+  // Default: Start the MCP server
+  // This is what gets run when npx outlook-mcp is called without arguments
+  const mcpServerPath = path.join(__dirname, 'index.js');
+  const child = spawn('node', [mcpServerPath], {
+    stdio: 'inherit',
+    env: process.env
+  });
+  
+  // Handle process termination
+  process.on('SIGINT', () => {
+    child.kill('SIGINT');
+    process.exit(0);
+  });
+  
+  process.on('SIGTERM', () => {
+    child.kill('SIGTERM');
+    process.exit(0);
+  });
+  
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+  
+  child.on('error', (error) => {
+    console.error('Error starting MCP server:', error.message);
+    process.exit(1);
+  });
+}