ms365-mcp-server 1.0.0

package/dist/utils/ms365-operations.js

@@ -0,0 +1,644 @@
+import { ms365Auth } from './ms365-auth.js';
+import { logger } from './api.js';
+/**
+ * Microsoft 365 operations manager class
+ */
+export class MS365Operations {
+    constructor() {
+        this.graphClient = null;
+    }
+    /**
+     * Set the Microsoft Graph client externally
+     */
+    setGraphClient(client) {
+        this.graphClient = client;
+    }
+    /**
+     * Get authenticated Microsoft Graph client
+     */
+    async getGraphClient() {
+        if (!this.graphClient) {
+            this.graphClient = await ms365Auth.getGraphClient();
+        }
+        return this.graphClient;
+    }
+    /**
+     * Build filter query for Microsoft Graph API
+     */
+    buildFilterQuery(criteria) {
+        const filters = [];
+        if (criteria.from) {
+            filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+        }
+        // Note: Cannot filter on toRecipients or ccRecipients as they are complex collections
+        // These will be handled by search API or manual filtering
+        if (criteria.subject) {
+            filters.push(`contains(subject,'${criteria.subject}')`);
+        }
+        if (criteria.after) {
+            const afterDate = new Date(criteria.after).toISOString();
+            filters.push(`receivedDateTime ge ${afterDate}`);
+        }
+        if (criteria.before) {
+            const beforeDate = new Date(criteria.before).toISOString();
+            filters.push(`receivedDateTime le ${beforeDate}`);
+        }
+        if (criteria.hasAttachment !== undefined) {
+            filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
+        }
+        if (criteria.isUnread !== undefined) {
+            filters.push(`isRead eq ${!criteria.isUnread}`);
+        }
+        if (criteria.importance) {
+            filters.push(`importance eq '${criteria.importance}'`);
+        }
+        return filters.join(' and ');
+    }
+    /**
+     * Build search query for Microsoft Graph API
+     */
+    buildSearchQuery(criteria) {
+        const searchTerms = [];
+        if (criteria.query) {
+            searchTerms.push(criteria.query);
+        }
+        // Build email-specific search terms using proper Microsoft Graph syntax
+        const emailSearchTerms = [];
+        if (criteria.from) {
+            emailSearchTerms.push(`from:${criteria.from}`);
+        }
+        if (criteria.to) {
+            emailSearchTerms.push(`to:${criteria.to}`);
+        }
+        if (criteria.cc) {
+            emailSearchTerms.push(`cc:${criteria.cc}`);
+        }
+        // Combine email search terms with OR logic
+        if (emailSearchTerms.length > 0) {
+            searchTerms.push(emailSearchTerms.join(' OR '));
+        }
+        if (criteria.subject) {
+            // For subject searches, we can use quotes if the subject contains spaces
+            if (criteria.subject.includes(' ')) {
+                searchTerms.push(`subject:"${criteria.subject}"`);
+            }
+            else {
+                searchTerms.push(`subject:${criteria.subject}`);
+            }
+        }
+        return searchTerms.join(' AND ');
+    }
+    /**
+     * Send an email
+     */
+    async sendEmail(message) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Prepare recipients
+            const toRecipients = message.to.map(email => ({
+                emailAddress: {
+                    address: email,
+                    name: email.split('@')[0]
+                }
+            }));
+            const ccRecipients = message.cc?.map(email => ({
+                emailAddress: {
+                    address: email,
+                    name: email.split('@')[0]
+                }
+            })) || [];
+            const bccRecipients = message.bcc?.map(email => ({
+                emailAddress: {
+                    address: email,
+                    name: email.split('@')[0]
+                }
+            })) || [];
+            // Prepare attachments
+            const attachments = message.attachments?.map(att => ({
+                '@odata.type': '#microsoft.graph.fileAttachment',
+                name: att.name,
+                contentBytes: att.contentBytes,
+                contentType: att.contentType || 'application/octet-stream'
+            })) || [];
+            // Prepare email body
+            const emailBody = {
+                subject: message.subject,
+                body: {
+                    contentType: message.bodyType === 'html' ? 'html' : 'text',
+                    content: message.body || ''
+                },
+                toRecipients,
+                ccRecipients,
+                bccRecipients,
+                importance: message.importance || 'normal',
+                attachments: attachments.length > 0 ? attachments : undefined
+            };
+            if (message.replyTo) {
+                emailBody.replyTo = [{
+                        emailAddress: {
+                            address: message.replyTo,
+                            name: message.replyTo.split('@')[0]
+                        }
+                    }];
+            }
+            // Send email
+            const result = await graphClient
+                .api('/me/sendMail')
+                .post({
+                message: emailBody
+            });
+            logger.log('Email sent successfully');
+            return {
+                id: result?.id || 'sent',
+                status: 'sent'
+            };
+        }
+        catch (error) {
+            logger.error('Error sending email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get email by ID
+     */
+    async getEmail(messageId, includeAttachments = false) {
+        try {
+            const graphClient = await this.getGraphClient();
+            let selectFields = 'id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink';
+            if (includeAttachments) {
+                selectFields += ',body';
+            }
+            const email = await graphClient
+                .api(`/me/messages/${messageId}`)
+                .select(selectFields)
+                .get();
+            const emailInfo = {
+                id: email.id,
+                subject: email.subject || '',
+                from: {
+                    name: email.from?.emailAddress?.name || '',
+                    address: email.from?.emailAddress?.address || ''
+                },
+                toRecipients: email.toRecipients?.map((recipient) => ({
+                    name: recipient.emailAddress?.name || '',
+                    address: recipient.emailAddress?.address || ''
+                })) || [],
+                ccRecipients: email.ccRecipients?.map((recipient) => ({
+                    name: recipient.emailAddress?.name || '',
+                    address: recipient.emailAddress?.address || ''
+                })) || [],
+                receivedDateTime: email.receivedDateTime,
+                sentDateTime: email.sentDateTime,
+                bodyPreview: email.bodyPreview || '',
+                isRead: email.isRead || false,
+                hasAttachments: email.hasAttachments || false,
+                importance: email.importance || 'normal',
+                conversationId: email.conversationId || '',
+                parentFolderId: email.parentFolderId || '',
+                webLink: email.webLink || ''
+            };
+            if (includeAttachments && email.body) {
+                emailInfo.body = email.body.content || '';
+            }
+            // Get attachments if requested
+            if (includeAttachments && email.hasAttachments) {
+                const attachments = await graphClient
+                    .api(`/me/messages/${messageId}/attachments`)
+                    .get();
+                emailInfo.attachments = attachments.value || [];
+            }
+            return emailInfo;
+        }
+        catch (error) {
+            logger.error('Error getting email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Search emails with criteria
+     */
+    async searchEmails(criteria = {}) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Build search and filter queries
+            const searchQuery = this.buildSearchQuery(criteria);
+            const filterQuery = this.buildFilterQuery(criteria);
+            let apiCall;
+            let useSearchAPI = !!searchQuery;
+            try {
+                // Microsoft Graph doesn't support $orderBy with $search, so we need to choose one approach
+                if (searchQuery) {
+                    // Use search API when we have search terms (no orderby allowed)
+                    // Add ConsistencyLevel header for search queries
+                    apiCall = graphClient.api('/me/messages')
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .header('ConsistencyLevel', 'eventual')
+                        .search(`"${searchQuery}"`)
+                        .top(criteria.maxResults || 50);
+                    // Can't use filter with search, so we'll need to filter results manually if needed
+                }
+                else {
+                    // Use filter API when we don't have search terms (orderby allowed)
+                    apiCall = graphClient.api('/me/messages')
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .orderby('receivedDateTime desc')
+                        .top(criteria.maxResults || 50);
+                    if (filterQuery) {
+                        apiCall = apiCall.filter(filterQuery);
+                    }
+                }
+                // Handle folder-specific searches
+                if (criteria.folder && criteria.folder !== 'inbox') {
+                    if (searchQuery) {
+                        // For folder + search, we need to use a different approach
+                        apiCall = graphClient.api(`/me/mailFolders/${criteria.folder}/messages`)
+                            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                            .top(criteria.maxResults || 50);
+                        if (filterQuery) {
+                            apiCall = apiCall.filter(filterQuery);
+                        }
+                        // Note: Folder-specific search is limited, we'll do text filtering on results
+                    }
+                    else {
+                        apiCall = graphClient.api(`/me/mailFolders/${criteria.folder}/messages`)
+                            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                            .orderby('receivedDateTime desc')
+                            .top(criteria.maxResults || 50);
+                        if (filterQuery) {
+                            apiCall = apiCall.filter(filterQuery);
+                        }
+                    }
+                }
+                const result = await apiCall.get();
+                let messages = result.value?.map((email) => ({
+                    id: email.id,
+                    subject: email.subject || '',
+                    from: {
+                        name: email.from?.emailAddress?.name || '',
+                        address: email.from?.emailAddress?.address || ''
+                    },
+                    toRecipients: email.toRecipients?.map((recipient) => ({
+                        name: recipient.emailAddress?.name || '',
+                        address: recipient.emailAddress?.address || ''
+                    })) || [],
+                    ccRecipients: email.ccRecipients?.map((recipient) => ({
+                        name: recipient.emailAddress?.name || '',
+                        address: recipient.emailAddress?.address || ''
+                    })) || [],
+                    receivedDateTime: email.receivedDateTime,
+                    sentDateTime: email.sentDateTime,
+                    bodyPreview: email.bodyPreview || '',
+                    isRead: email.isRead || false,
+                    hasAttachments: email.hasAttachments || false,
+                    importance: email.importance || 'normal',
+                    conversationId: email.conversationId || '',
+                    parentFolderId: email.parentFolderId || '',
+                    webLink: email.webLink || ''
+                })) || [];
+                // Apply manual filtering when using search (since we can't use $filter with $search)
+                if (useSearchAPI && (criteria.folder || filterQuery)) {
+                    messages = this.applyManualFiltering(messages, criteria);
+                }
+                return {
+                    messages,
+                    hasMore: !!result['@odata.nextLink']
+                };
+            }
+            catch (searchError) {
+                // If search API fails due to syntax error, fall back to filter-only approach
+                if (searchError.message && searchError.message.includes('Syntax error')) {
+                    logger.log('Search API failed with syntax error, falling back to filter-only query');
+                    // Fallback: Use only filter-based query without search
+                    apiCall = graphClient.api('/me/messages')
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .orderby('receivedDateTime desc')
+                        .top(criteria.maxResults || 50);
+                    if (filterQuery) {
+                        apiCall = apiCall.filter(filterQuery);
+                    }
+                    // Handle folder-specific queries
+                    if (criteria.folder && criteria.folder !== 'inbox') {
+                        apiCall = graphClient.api(`/me/mailFolders/${criteria.folder}/messages`)
+                            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                            .orderby('receivedDateTime desc')
+                            .top(criteria.maxResults || 50);
+                        if (filterQuery) {
+                            apiCall = apiCall.filter(filterQuery);
+                        }
+                    }
+                    const result = await apiCall.get();
+                    let messages = result.value?.map((email) => ({
+                        id: email.id,
+                        subject: email.subject || '',
+                        from: {
+                            name: email.from?.emailAddress?.name || '',
+                            address: email.from?.emailAddress?.address || ''
+                        },
+                        toRecipients: email.toRecipients?.map((recipient) => ({
+                            name: recipient.emailAddress?.name || '',
+                            address: recipient.emailAddress?.address || ''
+                        })) || [],
+                        ccRecipients: email.ccRecipients?.map((recipient) => ({
+                            name: recipient.emailAddress?.name || '',
+                            address: recipient.emailAddress?.address || ''
+                        })) || [],
+                        receivedDateTime: email.receivedDateTime,
+                        sentDateTime: email.sentDateTime,
+                        bodyPreview: email.bodyPreview || '',
+                        isRead: email.isRead || false,
+                        hasAttachments: email.hasAttachments || false,
+                        importance: email.importance || 'normal',
+                        conversationId: email.conversationId || '',
+                        parentFolderId: email.parentFolderId || '',
+                        webLink: email.webLink || ''
+                    })) || [];
+                    // Apply manual filtering for any criteria that couldn't be handled by the filter
+                    messages = this.applyManualFiltering(messages, criteria);
+                    return {
+                        messages,
+                        hasMore: !!result['@odata.nextLink']
+                    };
+                }
+                else {
+                    // Re-throw other errors
+                    throw searchError;
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Error searching emails:', error);
+            throw error;
+        }
+    }
+    /**
+     * Apply manual filtering to search results (used when $filter can't be used with $search)
+     */
+    applyManualFiltering(messages, criteria) {
+        return messages.filter(message => {
+            // Apply text search filters manually
+            if (criteria.query) {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                if (!messageText.includes(searchText))
+                    return false;
+            }
+            if (criteria.from) {
+                const fromMatch = message.from.address.toLowerCase().includes(criteria.from.toLowerCase()) ||
+                    message.from.name.toLowerCase().includes(criteria.from.toLowerCase());
+                if (!fromMatch)
+                    return false;
+            }
+            if (criteria.to) {
+                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase().includes(criteria.to.toLowerCase()) ||
+                    recipient.name.toLowerCase().includes(criteria.to.toLowerCase()));
+                if (!toMatch)
+                    return false;
+            }
+            if (criteria.cc) {
+                // Handle case where ccRecipients might be undefined
+                const ccMatch = message.ccRecipients && message.ccRecipients.length > 0 &&
+                    message.ccRecipients.some(recipient => recipient.address.toLowerCase().includes(criteria.cc.toLowerCase()) ||
+                        recipient.name.toLowerCase().includes(criteria.cc.toLowerCase()));
+                if (!ccMatch)
+                    return false;
+            }
+            if (criteria.subject) {
+                if (!message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
+                    return false;
+            }
+            // Apply date filters
+            if (criteria.after) {
+                const afterDate = new Date(criteria.after);
+                const messageDate = new Date(message.receivedDateTime);
+                if (messageDate < afterDate)
+                    return false;
+            }
+            if (criteria.before) {
+                const beforeDate = new Date(criteria.before);
+                const messageDate = new Date(message.receivedDateTime);
+                if (messageDate > beforeDate)
+                    return false;
+            }
+            // Apply attachment filter
+            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment) {
+                return false;
+            }
+            // Apply read status filter
+            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread) {
+                return false;
+            }
+            // Apply importance filter
+            if (criteria.importance && message.importance !== criteria.importance) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * List emails in a folder
+     */
+    async listEmails(folderId = 'inbox', maxResults = 50) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api(`/me/mailFolders/${folderId}/messages`)
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(maxResults)
+                .get();
+            const messages = result.value?.map((email) => ({
+                id: email.id,
+                subject: email.subject || '',
+                from: {
+                    name: email.from?.emailAddress?.name || '',
+                    address: email.from?.emailAddress?.address || ''
+                },
+                toRecipients: email.toRecipients?.map((recipient) => ({
+                    name: recipient.emailAddress?.name || '',
+                    address: recipient.emailAddress?.address || ''
+                })) || [],
+                ccRecipients: email.ccRecipients?.map((recipient) => ({
+                    name: recipient.emailAddress?.name || '',
+                    address: recipient.emailAddress?.address || ''
+                })) || [],
+                receivedDateTime: email.receivedDateTime,
+                sentDateTime: email.sentDateTime,
+                bodyPreview: email.bodyPreview || '',
+                isRead: email.isRead || false,
+                hasAttachments: email.hasAttachments || false,
+                importance: email.importance || 'normal',
+                conversationId: email.conversationId || '',
+                parentFolderId: email.parentFolderId || '',
+                webLink: email.webLink || ''
+            })) || [];
+            return {
+                messages,
+                hasMore: !!result['@odata.nextLink']
+            };
+        }
+        catch (error) {
+            logger.error('Error listing emails:', error);
+            throw error;
+        }
+    }
+    /**
+     * Mark email as read or unread
+     */
+    async markEmail(messageId, isRead) {
+        try {
+            const graphClient = await this.getGraphClient();
+            await graphClient
+                .api(`/me/messages/${messageId}`)
+                .patch({
+                isRead: isRead
+            });
+            logger.log(`Email ${messageId} marked as ${isRead ? 'read' : 'unread'}`);
+        }
+        catch (error) {
+            logger.error('Error marking email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Move email to folder
+     */
+    async moveEmail(messageId, destinationFolderId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            await graphClient
+                .api(`/me/messages/${messageId}/move`)
+                .post({
+                destinationId: destinationFolderId
+            });
+            logger.log(`Email ${messageId} moved to folder ${destinationFolderId}`);
+        }
+        catch (error) {
+            logger.error('Error moving email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete email
+     */
+    async deleteEmail(messageId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            await graphClient
+                .api(`/me/messages/${messageId}`)
+                .delete();
+            logger.log(`Email ${messageId} deleted`);
+        }
+        catch (error) {
+            logger.error('Error deleting email:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get attachment
+     */
+    async getAttachment(messageId, attachmentId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const attachment = await graphClient
+                .api(`/me/messages/${messageId}/attachments/${attachmentId}`)
+                .get();
+            return {
+                name: attachment.name || '',
+                contentType: attachment.contentType || 'application/octet-stream',
+                contentBytes: attachment.contentBytes || '',
+                size: attachment.size || 0
+            };
+        }
+        catch (error) {
+            logger.error('Error getting attachment:', error);
+            throw error;
+        }
+    }
+    /**
+     * List mail folders
+     */
+    async listFolders() {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api('/me/mailFolders')
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .get();
+            return result.value?.map((folder) => ({
+                id: folder.id,
+                displayName: folder.displayName || '',
+                totalItemCount: folder.totalItemCount || 0,
+                unreadItemCount: folder.unreadItemCount || 0,
+                parentFolderId: folder.parentFolderId
+            })) || [];
+        }
+        catch (error) {
+            logger.error('Error listing folders:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get contacts
+     */
+    async getContacts(maxResults = 100) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api('/me/contacts')
+                .select('id,displayName,emailAddresses,jobTitle,companyName,department,officeLocation,businessPhones,mobilePhone')
+                .top(maxResults)
+                .get();
+            return result.value?.map((contact) => ({
+                id: contact.id,
+                displayName: contact.displayName || '',
+                emailAddresses: contact.emailAddresses?.map((email) => ({
+                    name: email.name,
+                    address: email.address
+                })) || [],
+                jobTitle: contact.jobTitle,
+                companyName: contact.companyName,
+                department: contact.department,
+                officeLocation: contact.officeLocation,
+                businessPhones: contact.businessPhones || [],
+                mobilePhone: contact.mobilePhone
+            })) || [];
+        }
+        catch (error) {
+            logger.error('Error getting contacts:', error);
+            throw error;
+        }
+    }
+    /**
+     * Search contacts
+     */
+    async searchContacts(query, maxResults = 50) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api('/me/contacts')
+                .select('id,displayName,emailAddresses,jobTitle,companyName,department,officeLocation,businessPhones,mobilePhone')
+                .filter(`contains(displayName,'${query}') or contains(emailAddresses/any(e:e/address),'${query}')`)
+                .top(maxResults)
+                .get();
+            return result.value?.map((contact) => ({
+                id: contact.id,
+                displayName: contact.displayName || '',
+                emailAddresses: contact.emailAddresses?.map((email) => ({
+                    name: email.name,
+                    address: email.address
+                })) || [],
+                jobTitle: contact.jobTitle,
+                companyName: contact.companyName,
+                department: contact.department,
+                officeLocation: contact.officeLocation,
+                businessPhones: contact.businessPhones || [],
+                mobilePhone: contact.mobilePhone
+            })) || [];
+        }
+        catch (error) {
+            logger.error('Error searching contacts:', error);
+            throw error;
+        }
+    }
+}
+export const ms365Operations = new MS365Operations();