outlook-cli 1.2.0

package/auth/tools.js

@@ -0,0 +1,127 @@
+/**
+ * Authentication-related tools for the Outlook MCP server
+ */
+const config = require('../config');
+const tokenManager = require('./token-manager');
+
+/**
+ * About tool handler
+ * @returns {object} - MCP response
+ */
+async function handleAbout() {
+  return {
+    content: [{
+      type: "text",
+      text: `outlook-cli v${config.SERVER_VERSION}\n\nProduction-ready Outlook CLI and MCP server powered by Microsoft Graph API.`
+    }]
+  };
+}
+
+/**
+ * Authentication tool handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleAuthenticate(args) {
+  const force = args && args.force === true;
+  
+  // For test mode, create a test token
+  if (config.USE_TEST_MODE) {
+    // Create a test token with a 1-hour expiry
+    tokenManager.createTestTokens();
+    
+    return {
+      content: [{
+        type: "text",
+        text: 'Successfully authenticated with Microsoft Graph API (test mode)'
+      }]
+    };
+  }
+
+  if (force) {
+    tokenManager.clearTokenCache();
+  }
+
+  if (!config.AUTH_CONFIG.clientId) {
+    return {
+      content: [{
+        type: "text",
+        text: "Client ID is not configured. Set OUTLOOK_CLIENT_ID or MS_CLIENT_ID before authenticating."
+      }]
+    };
+  }
+  
+  // For real authentication, generate an auth URL and instruct the user to visit it
+  const authUrl = `${config.AUTH_CONFIG.authServerUrl}/auth?client_id=${config.AUTH_CONFIG.clientId}`;
+  
+  return {
+    content: [{
+      type: "text",
+      text: `Authentication required. Please visit the following URL to authenticate with Microsoft: ${authUrl}\n\nAfter authentication, you will be redirected back to this application.`
+    }]
+  };
+}
+
+/**
+ * Check authentication status tool handler
+ * @returns {object} - MCP response
+ */
+async function handleCheckAuthStatus() {
+  const accessToken = await tokenManager.getValidAccessToken();
+
+  if (!accessToken) {
+    return {
+      content: [{ type: "text", text: "Not authenticated" }]
+    };
+  }
+  
+  return {
+    content: [{ type: "text", text: "Authenticated and ready" }]
+  };
+}
+
+// Tool definitions
+const authTools = [
+  {
+    name: "about",
+    description: "Returns information about this Outlook Assistant server",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    handler: handleAbout
+  },
+  {
+    name: "authenticate",
+    description: "Authenticate with Microsoft Graph API to access Outlook data",
+    inputSchema: {
+      type: "object",
+      properties: {
+        force: {
+          type: "boolean",
+          description: "Force re-authentication even if already authenticated"
+        }
+      },
+      required: []
+    },
+    handler: handleAuthenticate
+  },
+  {
+    name: "check-auth-status",
+    description: "Check the current authentication status with Microsoft Graph API",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    handler: handleCheckAuthStatus
+  }
+];
+
+module.exports = {
+  authTools,
+  handleAbout,
+  handleAuthenticate,
+  handleCheckAuthStatus
+};

package/calendar/accept.js

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

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;