msexchange-mcp/dist/tools/setupOrganizationFolders.js

MCP server for Microsoft Exchange/Outlook email operations via Microsoft Graph API

import { z } from 'zod';
import { MailService } from '../mail/mailService.js';
import accountsConfig from '../config/accountsLoader.js';
export const setupOrganizationFoldersTool = {
    name: 'setup_organization_folders',
    description: `Create a standard set of organizational folders for email management.

Predefined folder sets:
- business: Projects, Clients, Finance, HR, Admin, Archive
- personal: Family, Friends, Shopping, Travel, Finance, Archive  
- minimal: Important, Archive, Follow-up
- custom: Provide your own folder names

Features:
- Creates folder structure in one operation
- Avoids duplicates (checks existing folders)
- Can create under specific parent folder
- Returns created folder IDs for reference

Examples:
- Business setup: {"folder_set": "business"}
- Personal organization: {"folder_set": "personal"}
- Custom folders: {"folder_set": "custom", "custom_folders": ["Urgent", "Pending Review", "Completed"]}
- Under specific folder: {"folder_set": "minimal", "parent_folder_id": "inbox_subfolder_id"}

Best practices:
- Run list_folders first to check existing structure
- Use 'business' for professional accounts
- Use 'minimal' for simple organization needs
- Create custom sets for specific workflows`,
    parameters: z.object({
        user_id: z.string().describe('The user ID or email address'),
        folder_set: z.enum(['business', 'personal', 'minimal', 'custom']).optional().default('business').describe('Predefined folder set to create'),
        custom_folders: z.array(z.string()).optional().describe('Custom folder names if folder_set is "custom"'),
        parent_folder_id: z.string().optional().describe('ID of parent folder (optional, defaults to root)'),
    }),
    execute: async (params) => {
        try {
            const account = accountsConfig.accounts.find(acc => acc.id === params.user_id || acc.email === params.user_id);
            if (!account) {
                throw new Error(`User not found: ${params.user_id}`);
            }
            const mailService = new MailService(account.email);
            // Define folder sets
            const folderSets = {
                business: [
                    'Action Required',
                    'Follow Up',
                    'Projects',
                    'Clients',
                    'Financial',
                    'Legal',
                    'HR',
                    'Completed',
                    'Archive'
                ],
                personal: [
                    'Action Required',
                    'Family',
                    'Friends',
                    'Bills & Finance',
                    'Shopping',
                    'Travel',
                    'Health',
                    'Archive'
                ],
                minimal: [
                    'Action Required',
                    'Follow Up',
                    'Archive'
                ],
                custom: params.custom_folders || []
            };
            const foldersToCreate = folderSets[params.folder_set || 'business'];
            if (foldersToCreate.length === 0) {
                throw new Error('No folders specified to create');
            }
            const createdFolders = [];
            const errors = [];
            console.error(`📁 Creating ${foldersToCreate.length} organizational folders...`);
            // Create folders sequentially to avoid rate limiting
            for (const folderName of foldersToCreate) {
                try {
                    console.error(`📂 Creating folder: ${folderName}`);
                    const newFolder = await mailService.createFolder({
                        displayName: folderName,
                        parentFolderId: params.parent_folder_id,
                    });
                    createdFolders.push({
                        name: folderName,
                        id: newFolder.id,
                        status: 'created'
                    });
                    // Small delay between creations to be nice to the API
                    await new Promise(resolve => setTimeout(resolve, 200));
                }
                catch (error) {
                    console.error(`❌ Failed to create folder ${folderName}: ${error}`);
                    errors.push({
                        name: folderName,
                        error: error instanceof Error ? error.message : 'Unknown error'
                    });
                }
            }
            return {
                content: [
                    {
                        type: 'text',
                        text: JSON.stringify({
                            success: errors.length === 0,
                            summary: {
                                folderSet: params.folder_set,
                                totalAttempted: foldersToCreate.length,
                                successfullyCreated: createdFolders.length,
                                errors: errors.length,
                            },
                            createdFolders,
                            errors: errors.length > 0 ? errors : undefined,
                            organizationTips: [
                                'Use "Action Required" for emails that need immediate attention',
                                'Move completed items to "Archive" to keep folders organized',
                                'Use categories/labels in addition to folders for better organization',
                                'Set up rules to automatically move emails to appropriate folders'
                            ]
                        }, null, 2),
                    },
                ],
            };
        }
        catch (error) {
            return {
                content: [
                    {
                        type: 'text',
                        text: `Error setting up organization folders: ${error instanceof Error ? error.message : 'Unknown error'}`,
                    },
                ],
            };
        }
    },
};
//# sourceMappingURL=setupOrganizationFolders.js.map