@littlebearapps/outlook-assistant 3.3.0

package/email/send.js

@@ -0,0 +1,169 @@
+/**
+ * Send email functionality
+ */
+const _config = require('../config'); // Reserved for future use
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const {
+  checkRateLimit,
+  checkRecipientAllowlist,
+  formatDryRunPreview,
+} = require('../utils/safety');
+
+/**
+ * Send email handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleSendEmail(args) {
+  const {
+    to,
+    cc,
+    bcc,
+    subject,
+    body,
+    importance = 'normal',
+    saveToSentItems = true,
+    dryRun = false,
+  } = args;
+
+  // Validate required parameters
+  if (!to) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Recipient (to) is required.',
+        },
+      ],
+    };
+  }
+
+  if (!subject) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Subject is required.',
+        },
+      ],
+    };
+  }
+
+  if (!body) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Body content is required.',
+        },
+      ],
+    };
+  }
+
+  try {
+    // Format recipients
+    const toRecipients = to.split(',').map((email) => {
+      email = email.trim();
+      return {
+        emailAddress: {
+          address: email,
+        },
+      };
+    });
+
+    const ccRecipients = cc
+      ? cc.split(',').map((email) => {
+          email = email.trim();
+          return {
+            emailAddress: {
+              address: email,
+            },
+          };
+        })
+      : [];
+
+    const bccRecipients = bcc
+      ? bcc.split(',').map((email) => {
+          email = email.trim();
+          return {
+            emailAddress: {
+              address: email,
+            },
+          };
+        })
+      : [];
+
+    // Check recipient allowlist (all recipients combined)
+    const allRecipients = [...toRecipients, ...ccRecipients, ...bccRecipients];
+    const allowlistError = checkRecipientAllowlist(allRecipients);
+    if (allowlistError) return allowlistError;
+
+    // Prepare email object
+    const emailObject = {
+      message: {
+        subject,
+        body: {
+          contentType:
+            /<(html|div|p|h[1-6]|br|table|ul|ol|li|span|a\s|img|strong|em|b|i)\b/i.test(
+              body
+            )
+              ? 'html'
+              : 'text',
+          content: body,
+        },
+        toRecipients,
+        ccRecipients: ccRecipients.length > 0 ? ccRecipients : undefined,
+        bccRecipients: bccRecipients.length > 0 ? bccRecipients : undefined,
+        importance,
+      },
+      saveToSentItems,
+    };
+
+    // Dry-run mode: return preview without sending
+    if (dryRun) {
+      return formatDryRunPreview(emailObject);
+    }
+
+    // Check rate limit (only for actual sends, not dry runs)
+    const rateLimitError = checkRateLimit('send-email');
+    if (rateLimitError) return rateLimitError;
+
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+
+    // Make API call to send email
+    await callGraphAPI(accessToken, 'POST', 'me/sendMail', emailObject);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Email sent successfully!\n\nSubject: ${subject}\nRecipients: ${toRecipients.length}${ccRecipients.length > 0 ? ` + ${ccRecipients.length} CC` : ''}${bccRecipients.length > 0 ? ` + ${bccRecipients.length} BCC` : ''}\nMessage Length: ${body.length} characters`,
+        },
+      ],
+    };
+  } 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 sending email: ${error.message}`,
+        },
+      ],
+    };
+  }
+}
+
+module.exports = handleSendEmail;

package/folder/create.js

@@ -0,0 +1,137 @@
+/**
+ * Create folder functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { getFolderIdByName } = require('../email/folder-utils');
+
+/**
+ * Create folder handler
+ * @param {object} args - Tool arguments
+ * @returns {object} - MCP response
+ */
+async function handleCreateFolder(args) {
+  const folderName = args.name;
+  const parentFolder = args.parentFolder || '';
+
+  if (!folderName) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Folder name is required.',
+        },
+      ],
+    };
+  }
+
+  try {
+    // Get access token
+    const accessToken = await ensureAuthenticated();
+
+    // Create folder with appropriate parent
+    const result = await createMailFolder(
+      accessToken,
+      folderName,
+      parentFolder
+    );
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.message,
+        },
+      ],
+    };
+  } 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 folder: ${error.message}`,
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Create a new mail folder
+ * @param {string} accessToken - Access token
+ * @param {string} folderName - Name of the folder to create
+ * @param {string} parentFolderName - Name of the parent folder (optional)
+ * @returns {Promise<object>} - Result object with status and message
+ */
+async function createMailFolder(accessToken, folderName, parentFolderName) {
+  try {
+    // Check if a folder with this name already exists
+    const existingFolder = await getFolderIdByName(accessToken, folderName);
+    if (existingFolder) {
+      return {
+        success: false,
+        message: `A folder named "${folderName}" already exists.`,
+      };
+    }
+
+    // If parent folder specified, find its ID
+    let endpoint = 'me/mailFolders';
+    if (parentFolderName) {
+      const parentId = await getFolderIdByName(accessToken, parentFolderName);
+      if (!parentId) {
+        return {
+          success: false,
+          message: `Parent folder "${parentFolderName}" not found. Please specify a valid parent folder or leave it blank to create at the root level.`,
+        };
+      }
+
+      endpoint = `me/mailFolders/${parentId}/childFolders`;
+    }
+
+    // Create the folder
+    const folderData = {
+      displayName: folderName,
+    };
+
+    const response = await callGraphAPI(
+      accessToken,
+      'POST',
+      endpoint,
+      folderData
+    );
+
+    if (response && response.id) {
+      const locationInfo = parentFolderName
+        ? `inside "${parentFolderName}"`
+        : 'at the root level';
+
+      return {
+        success: true,
+        message: `Successfully created folder "${folderName}" ${locationInfo}.`,
+        folderId: response.id,
+      };
+    } else {
+      return {
+        success: false,
+        message:
+          "Failed to create folder. The server didn't return a folder ID.",
+      };
+    }
+  } catch (error) {
+    console.error(`Error creating folder "${folderName}": ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = handleCreateFolder;

package/folder/delete.js

@@ -0,0 +1,108 @@
+/**
+ * Delete folder functionality
+ */
+const { callGraphAPI } = require('../utils/graph-api');
+const { ensureAuthenticated } = require('../auth');
+const { getFolderIdByName } = require('../email/folder-utils');
+
+/**
+ * Protected folder names that cannot be deleted
+ */
+const PROTECTED_FOLDERS = [
+  'inbox',
+  'drafts',
+  'sentitems',
+  'deleteditems',
+  'junkemail',
+  'archive',
+  'outbox',
+];
+
+/**
+ * Delete folder handler
+ * @param {object} args - Tool arguments
+ * @param {string} [args.folderId] - Folder ID to delete
+ * @param {string} [args.folderName] - Folder name to delete (resolved to ID)
+ * @returns {object} - MCP response
+ */
+async function handleDeleteFolder(args) {
+  const { folderId, folderName } = args;
+
+  if (!folderId && !folderName) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Either folderId or folderName is required.',
+        },
+      ],
+    };
+  }
+
+  // Guard against deleting protected folders
+  if (folderName && PROTECTED_FOLDERS.includes(folderName.toLowerCase())) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Cannot delete protected folder "${folderName}". Protected folders: Inbox, Drafts, Sent Items, Deleted Items, Junk Email, Archive, Outbox.`,
+        },
+      ],
+    };
+  }
+
+  try {
+    const accessToken = await ensureAuthenticated();
+
+    let resolvedId = folderId;
+
+    // Resolve folder name to ID if needed
+    if (!resolvedId && folderName) {
+      resolvedId = await getFolderIdByName(accessToken, folderName);
+      if (!resolvedId) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Folder "${folderName}" not found. Use folders (action=list) to see available folders.`,
+            },
+          ],
+        };
+      }
+    }
+
+    // Delete the folder
+    await callGraphAPI(accessToken, 'DELETE', `me/mailFolders/${resolvedId}`);
+
+    const displayName = folderName || resolvedId;
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Folder "${displayName}" deleted successfully.`,
+        },
+      ],
+    };
+  } 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 deleting folder: ${error.message}`,
+        },
+      ],
+    };
+  }
+}
+
+module.exports = handleDeleteFolder;

package/folder/index.js

@@ -0,0 +1,112 @@
+/**
+ * Folder management module for Outlook Assistant server
+ */
+const handleListFolders = require('./list');
+const handleCreateFolder = require('./create');
+const handleMoveEmails = require('./move');
+const handleGetFolderStats = require('./stats');
+const handleDeleteFolder = require('./delete');
+
+// Consolidated folder tool definition
+const folderTools = [
+  {
+    name: 'folders',
+    description:
+      'Manage mail folders. action=list (default) lists folders. action=create creates a folder. action=move moves emails between folders. action=stats gets folder counts for pagination planning. action=delete removes a folder.',
+    annotations: {
+      title: 'Mail Folders',
+      readOnlyHint: false,
+      destructiveHint: true,
+      openWorldHint: false,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'create', 'move', 'stats', 'delete'],
+          description: 'Action to perform (default: list)',
+        },
+        // list params
+        includeItemCounts: {
+          type: 'boolean',
+          description: 'Include counts of total and unread items (action=list)',
+        },
+        includeChildren: {
+          type: 'boolean',
+          description: 'Include child folders in hierarchy (action=list)',
+        },
+        // create params
+        name: {
+          type: 'string',
+          description: 'Name of the folder to create (action=create, required)',
+        },
+        parentFolder: {
+          type: 'string',
+          description: 'Parent folder name, default is root (action=create)',
+        },
+        // move params
+        emailIds: {
+          type: 'string',
+          description:
+            'Comma-separated list of email IDs to move (action=move, required)',
+        },
+        targetFolder: {
+          type: 'string',
+          description: 'Folder name to move emails to (action=move, required)',
+        },
+        sourceFolder: {
+          type: 'string',
+          description: 'Source folder name, default is inbox (action=move)',
+        },
+        // stats params
+        folder: {
+          type: 'string',
+          description:
+            'Folder name (inbox, sent, drafts, etc.). Default: inbox (action=stats)',
+        },
+        outputVerbosity: {
+          type: 'string',
+          enum: ['minimal', 'standard', 'full'],
+          description: 'Output detail level (action=stats, default: standard)',
+        },
+        // delete params
+        folderId: {
+          type: 'string',
+          description: 'Folder ID to delete (action=delete)',
+        },
+        folderName: {
+          type: 'string',
+          description:
+            'Folder name to delete — resolved to ID (action=delete). Cannot delete protected folders (Inbox, Drafts, Sent, etc.)',
+        },
+      },
+      required: [],
+    },
+    handler: async (args) => {
+      const action = args.action || 'list';
+      switch (action) {
+        case 'create':
+          return handleCreateFolder(args);
+        case 'move':
+          return handleMoveEmails(args);
+        case 'stats':
+          return handleGetFolderStats(args);
+        case 'delete':
+          return handleDeleteFolder(args);
+        case 'list':
+        default:
+          return handleListFolders(args);
+      }
+    },
+  },
+];
+
+module.exports = {
+  folderTools,
+  handleListFolders,
+  handleCreateFolder,
+  handleMoveEmails,
+  handleGetFolderStats,
+  handleDeleteFolder,
+};