@littlebearapps/outlook-assistant 3.3.0

package/auth/tools.js

@@ -0,0 +1,159 @@
+/**
+ * Authentication-related tools for the Outlook Assistant server
+ */
+const config = require('../config');
+const tokenManager = require('./token-manager');
+
+/**
+ * About tool handler
+ * @returns {object} - MCP response
+ */
+async function handleAbout() {
+  const scopes = config.AUTH_CONFIG.scopes.filter(
+    (s) => s !== 'offline_access'
+  );
+  const testMode = config.USE_TEST_MODE ? 'Enabled' : 'Disabled';
+  const rateLimit =
+    process.env.OUTLOOK_MAX_EMAILS_PER_SESSION || 'Unlimited (no limit set)';
+  const allowlist =
+    process.env.OUTLOOK_ALLOWED_RECIPIENTS || 'None (all recipients allowed)';
+
+  const lines = [
+    `# Outlook Assistant Server v${config.SERVER_VERSION}\n`,
+    `Provides access to Microsoft Outlook email, calendar, and contacts through Microsoft Graph API.\n`,
+    `## Diagnostics\n`,
+    `| Setting | Value |`,
+    `|---------|-------|`,
+    `| Tools | 20 across 9 modules |`,
+    `| Modules | auth, email, calendar, folder, rules, contacts, categories, settings, advanced |`,
+    `| Timezone | ${config.DEFAULT_TIMEZONE} |`,
+    `| Test Mode | ${testMode} |`,
+    `| Rate Limit | ${rateLimit} |`,
+    `| Recipient Allowlist | ${allowlist} |`,
+    `| Scopes | ${scopes.length} configured |`,
+    ``,
+    `**Scopes**: ${scopes.join(', ')}`,
+  ];
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: lines.join('\n'),
+      },
+    ],
+  };
+}
+
+/**
+ * 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)',
+        },
+      ],
+    };
+  }
+
+  // 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() {
+  console.error('[CHECK-AUTH-STATUS] Starting authentication status check');
+
+  const tokens = tokenManager.loadTokenCache();
+
+  console.error(`[CHECK-AUTH-STATUS] Tokens loaded: ${tokens ? 'YES' : 'NO'}`);
+
+  if (!tokens || !tokens.access_token) {
+    console.error('[CHECK-AUTH-STATUS] No valid access token found');
+    return {
+      content: [{ type: 'text', text: 'Not authenticated' }],
+    };
+  }
+
+  console.error('[CHECK-AUTH-STATUS] Access token present');
+  console.error(`[CHECK-AUTH-STATUS] Token expires at: ${tokens.expires_at}`);
+  console.error(`[CHECK-AUTH-STATUS] Current time: ${Date.now()}`);
+
+  return {
+    content: [{ type: 'text', text: 'Authenticated and ready' }],
+  };
+}
+
+// Tool definitions
+const authTools = [
+  {
+    name: 'auth',
+    description:
+      'Manage authentication with Microsoft Graph API. action=status (default) checks auth state, action=authenticate starts OAuth flow, action=about shows server info.',
+    annotations: {
+      title: 'Authentication',
+      readOnlyHint: false,
+      destructiveHint: false,
+      openWorldHint: false,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['status', 'authenticate', 'about'],
+          description: 'Action to perform (default: status)',
+        },
+        force: {
+          type: 'boolean',
+          description:
+            'Force re-authentication even if already authenticated (action=authenticate only)',
+        },
+      },
+      required: [],
+    },
+    handler: async (args) => {
+      const action = args.action || 'status';
+      switch (action) {
+        case 'authenticate':
+          return handleAuthenticate(args);
+        case 'about':
+          return handleAbout();
+        case 'status':
+        default:
+          return handleCheckAuthStatus();
+      }
+    },
+  },
+];
+
+module.exports = {
+  authTools,
+  handleAbout,
+  handleAuthenticate,
+  handleCheckAuthStatus,
+};

package/calendar/accept.js

@@ -0,0 +1,72 @@
+/**
+ * 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,72 @@
+/**
+ * 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,115 @@
+/**
+ * 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
+    );
+
+    const output = [`Event '${subject}' has been successfully created.`];
+    if (response.id) {
+      output.push(`**ID**: \`${response.id}\``);
+    }
+    if (response.start) {
+      output.push(
+        `**Start**: ${response.start.dateTime} (${response.start.timeZone})`
+      );
+    }
+    if (response.end) {
+      output.push(
+        `**End**: ${response.end.dateTime} (${response.end.timeZone})`
+      );
+    }
+    if (response.webLink) {
+      output.push(`**Link**: ${response.webLink}`);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: output.join('\n'),
+        },
+      ],
+      _meta: {
+        eventId: response.id,
+        subject: response.subject,
+        start: response.start,
+        end: response.end,
+      },
+    };
+  } 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,72 @@
+/**
+ * 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,67 @@
+/**
+ * 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,130 @@
+/**
+ * Calendar module for Outlook Assistant server
+ */
+const handleListEvents = require('./list');
+const handleDeclineEvent = require('./decline');
+const handleCreateEvent = require('./create');
+const handleCancelEvent = require('./cancel');
+const handleDeleteEvent = require('./delete');
+
+// Calendar tool definitions (consolidated: 5 → 3)
+const calendarTools = [
+  {
+    name: 'list-events',
+    description: 'Lists upcoming events from your calendar',
+    annotations: {
+      title: 'List Calendar Events',
+      readOnlyHint: true,
+      openWorldHint: false,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        count: {
+          type: 'number',
+          description: 'Number of events to retrieve (default: 10, max: 50)',
+        },
+      },
+      required: [],
+    },
+    handler: handleListEvents,
+  },
+  {
+    name: 'create-event',
+    description: 'Creates a new calendar event',
+    annotations: {
+      title: 'Create Calendar Event',
+      readOnlyHint: false,
+      destructiveHint: false,
+      openWorldHint: false,
+    },
+    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: 'manage-event',
+    description:
+      'Manage an existing calendar event. action=decline declines an invitation. action=cancel cancels an event you organised. action=delete permanently removes an event.',
+    annotations: {
+      title: 'Manage Calendar Event',
+      readOnlyHint: false,
+      destructiveHint: true,
+      openWorldHint: false,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['decline', 'cancel', 'delete'],
+          description: 'Action to perform (required)',
+        },
+        eventId: {
+          type: 'string',
+          description: 'The ID of the event',
+        },
+        comment: {
+          type: 'string',
+          description: 'Optional comment for declining or cancelling the event',
+        },
+      },
+      required: ['action', 'eventId'],
+    },
+    handler: async (args) => {
+      switch (args.action) {
+        case 'decline':
+          return handleDeclineEvent(args);
+        case 'cancel':
+          return handleCancelEvent(args);
+        case 'delete':
+          return handleDeleteEvent(args);
+        default:
+          return {
+            content: [
+              {
+                type: 'text',
+                text: "Invalid action. Use 'decline', 'cancel', or 'delete'.",
+              },
+            ],
+          };
+      }
+    },
+  },
+];
+
+module.exports = {
+  calendarTools,
+  handleListEvents,
+  handleDeclineEvent,
+  handleCreateEvent,
+  handleCancelEvent,
+  handleDeleteEvent,
+};