ms365-mcp-server 1.1.9 → 1.1.11

package/dist/utils/ms365-operations.js

@@ -290,6 +290,19 @@ export class MS365Operations {
                 importance: message.importance || 'normal',
                 attachments: attachments.length > 0 ? attachments : undefined
             };
+            // Handle threading - set conversationId for replies/forwards
+            if (message.conversationId) {
+                draftBody.conversationId = message.conversationId;
+            }
+            // Handle in-reply-to for proper threading
+            if (message.inReplyTo) {
+                draftBody.internetMessageHeaders = [
+                    {
+                        name: 'In-Reply-To',
+                        value: message.inReplyTo
+                    }
+                ];
+            }
             if (message.replyTo) {
                 draftBody.replyTo = [{
                         emailAddress: {
@@ -313,6 +326,211 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Update a draft email
+     */
+    async updateDraftEmail(draftId, updates) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Prepare update payload
+            const updateBody = {};
+            if (updates.subject) {
+                updateBody.subject = updates.subject;
+            }
+            if (updates.body) {
+                updateBody.body = {
+                    contentType: updates.bodyType === 'html' ? 'html' : 'text',
+                    content: updates.body
+                };
+            }
+            if (updates.to) {
+                updateBody.toRecipients = updates.to.map(email => ({
+                    emailAddress: {
+                        address: email,
+                        name: email.split('@')[0]
+                    }
+                }));
+            }
+            if (updates.cc) {
+                updateBody.ccRecipients = updates.cc.map(email => ({
+                    emailAddress: {
+                        address: email,
+                        name: email.split('@')[0]
+                    }
+                }));
+            }
+            if (updates.bcc) {
+                updateBody.bccRecipients = updates.bcc.map(email => ({
+                    emailAddress: {
+                        address: email,
+                        name: email.split('@')[0]
+                    }
+                }));
+            }
+            if (updates.importance) {
+                updateBody.importance = updates.importance;
+            }
+            if (updates.replyTo) {
+                updateBody.replyTo = [{
+                        emailAddress: {
+                            address: updates.replyTo,
+                            name: updates.replyTo.split('@')[0]
+                        }
+                    }];
+            }
+            // Update attachments if provided
+            if (updates.attachments) {
+                updateBody.attachments = updates.attachments.map(att => ({
+                    '@odata.type': '#microsoft.graph.fileAttachment',
+                    name: att.name,
+                    contentBytes: att.contentBytes,
+                    contentType: att.contentType || 'application/octet-stream'
+                }));
+            }
+            // Update the draft
+            const result = await graphClient
+                .api(`/me/messages/${draftId}`)
+                .patch(updateBody);
+            logger.log(`Draft email ${draftId} updated successfully`);
+            return {
+                id: result.id || draftId,
+                status: 'draft_updated'
+            };
+        }
+        catch (error) {
+            logger.error(`Error updating draft email ${draftId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Send a draft email
+     */
+    async sendDraftEmail(draftId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Send the draft
+            await graphClient
+                .api(`/me/messages/${draftId}/send`)
+                .post({});
+            logger.log(`Draft email ${draftId} sent successfully`);
+            return {
+                id: draftId,
+                status: 'sent'
+            };
+        }
+        catch (error) {
+            logger.error(`Error sending draft email ${draftId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * List draft emails
+     */
+    async listDrafts(maxResults = 50) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api('/me/mailFolders/drafts/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink,isDraft')
+                .orderby('createdDateTime 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 || '',
+                attachments: []
+            })) || [];
+            return {
+                messages,
+                hasMore: !!result['@odata.nextLink']
+            };
+        }
+        catch (error) {
+            logger.error('Error listing draft emails:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a threaded reply draft from a specific message
+     */
+    async createReplyDraft(originalMessageId, body, replyToAll = false) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Use Microsoft Graph's createReply endpoint for proper threading
+            const endpoint = replyToAll
+                ? `/me/messages/${originalMessageId}/createReplyAll`
+                : `/me/messages/${originalMessageId}/createReply`;
+            const requestBody = {};
+            // If body is provided, include it as a comment
+            if (body) {
+                requestBody.comment = body;
+            }
+            const replyDraft = await graphClient
+                .api(endpoint)
+                .post(requestBody);
+            return {
+                id: replyDraft.id,
+                subject: replyDraft.subject,
+                conversationId: replyDraft.conversationId,
+                toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
+                ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
+                bodyPreview: replyDraft.bodyPreview,
+                isDraft: replyDraft.isDraft
+            };
+        }
+        catch (error) {
+            throw new Error(`Error creating reply draft: ${error}`);
+        }
+    }
+    /**
+     * Create a threaded forward draft from a specific message
+     */
+    async createForwardDraft(originalMessageId, comment) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Use Microsoft Graph's createForward endpoint for proper threading
+            const endpoint = `/me/messages/${originalMessageId}/createForward`;
+            const requestBody = {};
+            // If comment is provided, include it
+            if (comment) {
+                requestBody.comment = comment;
+            }
+            const forwardDraft = await graphClient
+                .api(endpoint)
+                .post(requestBody);
+            return {
+                id: forwardDraft.id,
+                subject: forwardDraft.subject,
+                conversationId: forwardDraft.conversationId,
+                bodyPreview: forwardDraft.bodyPreview,
+                isDraft: forwardDraft.isDraft
+            };
+        }
+        catch (error) {
+            throw new Error(`Error creating forward draft: ${error}`);
+        }
+    }
     /**
      * Get email by ID
      */
@@ -425,7 +643,7 @@ export class MS365Operations {
         }
     }
     /**
-     * Search emails with criteria
+     * Advanced email search using Microsoft Graph Search API with KQL - Persistent search until results found
      */
     async searchEmails(criteria = {}) {
         return await this.executeWithAuth(async () => {
@@ -436,152 +654,491 @@ export class MS365Operations {
             if (cachedResults) {
                 return cachedResults;
             }
-            // For complex searches, use a simpler approach
+            const maxResults = criteria.maxResults || 50;
+            let allMessages = [];
+            let searchAttempts = 0;
+            const maxAttempts = 6; // Try multiple strategies
+            logger.log(`🔍 Starting persistent search with criteria: ${JSON.stringify(criteria)}`);
             try {
-                // Start with a basic query to get recent emails
-                const 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 || 100);
-                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 all criteria
-                messages = this.applyManualFiltering(messages, criteria);
-                // For emails with attachments, get attachment counts
-                for (const message of messages) {
-                    if (message.hasAttachments) {
-                        try {
-                            const attachments = await graphClient
-                                .api(`/me/messages/${message.id}/attachments`)
-                                .select('id')
-                                .get();
-                            message.attachments = new Array(attachments.value?.length || 0);
+                // Strategy 1: Use Microsoft Graph Search API for text-based queries
+                if (criteria.query && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using Graph Search API for query: "${criteria.query}"`);
+                    const searchResults = await this.performGraphSearch(criteria.query, maxResults * 2); // Search for more to increase chances
+                    allMessages.push(...searchResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with Graph Search API`);
+                    }
+                }
+                // Strategy 2: Use KQL (Keyword Query Language) for advanced searches
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    const kqlQuery = this.buildKQLQuery(criteria);
+                    if (kqlQuery) {
+                        searchAttempts++;
+                        logger.log(`🔍 Attempt ${searchAttempts}: Using KQL search: "${kqlQuery}"`);
+                        const kqlResults = await this.performKQLSearch(kqlQuery, maxResults * 2);
+                        allMessages.push(...kqlResults);
+                        if (allMessages.length > 0) {
+                            logger.log(`✅ Found ${allMessages.length} results with KQL search`);
                         }
-                        catch (error) {
-                            logger.error(`Error getting attachment count for message ${message.id}:`, error);
-                            message.attachments = [];
+                    }
+                }
+                // Strategy 3: Try relaxed KQL search (remove some constraints)
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    const relaxedKQL = this.buildRelaxedKQLQuery(criteria);
+                    if (relaxedKQL && relaxedKQL !== this.buildKQLQuery(criteria)) {
+                        searchAttempts++;
+                        logger.log(`🔍 Attempt ${searchAttempts}: Using relaxed KQL search: "${relaxedKQL}"`);
+                        const relaxedResults = await this.performKQLSearch(relaxedKQL, maxResults * 2);
+                        allMessages.push(...relaxedResults);
+                        if (allMessages.length > 0) {
+                            logger.log(`✅ Found ${allMessages.length} results with relaxed KQL search`);
                         }
                     }
                 }
+                // Strategy 4: OData filter search with broader scope
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using OData filter search with broader scope`);
+                    const filterResults = await this.performFilteredSearch(criteria, maxResults * 3); // Even broader search
+                    allMessages.push(...filterResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with OData filter search`);
+                    }
+                }
+                // Strategy 5: Partial text search across recent emails (expanded scope)
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using expanded partial text search`);
+                    const partialResults = await this.performPartialTextSearch(criteria, maxResults * 4); // Very broad search
+                    allMessages.push(...partialResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with partial text search`);
+                    }
+                }
+                // Strategy 6: Fallback to basic search with maximum scope
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using fallback basic search with maximum scope`);
+                    const basicResult = await this.performBasicSearch({
+                        ...criteria,
+                        maxResults: Math.max(maxResults * 5, 500) // Very large scope
+                    });
+                    allMessages.push(...basicResult.messages);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with basic search fallback`);
+                    }
+                }
+                // Remove duplicates and apply advanced filtering
+                const uniqueMessages = this.removeDuplicateMessages(allMessages);
+                logger.log(`📧 After deduplication: ${uniqueMessages.length} unique messages`);
+                const filteredMessages = this.applyAdvancedFiltering(uniqueMessages, criteria);
+                logger.log(`📧 After advanced filtering: ${filteredMessages.length} filtered messages`);
+                // Sort by relevance and date
+                const sortedMessages = this.sortSearchResults(filteredMessages, criteria);
+                // If still no results, try one more time with very relaxed criteria
+                if (sortedMessages.length === 0 && (criteria.query || criteria.from || criteria.subject)) {
+                    logger.log(`🔍 Final attempt: Ultra-relaxed search for any partial matches`);
+                    const ultraRelaxedResults = await this.performUltraRelaxedSearch(criteria, maxResults * 3);
+                    const finalFiltered = this.applyUltraRelaxedFiltering(ultraRelaxedResults, criteria);
+                    if (finalFiltered.length > 0) {
+                        logger.log(`✅ Ultra-relaxed search found ${finalFiltered.length} results`);
+                        const limitedMessages = finalFiltered.slice(0, maxResults);
+                        const searchResult = {
+                            messages: limitedMessages,
+                            hasMore: finalFiltered.length > maxResults
+                        };
+                        this.setCachedResults(cacheKey, searchResult);
+                        return searchResult;
+                    }
+                }
+                // Limit results
+                const limitedMessages = sortedMessages.slice(0, maxResults);
                 const searchResult = {
-                    messages,
-                    hasMore: !!result['@odata.nextLink']
+                    messages: limitedMessages,
+                    hasMore: sortedMessages.length > maxResults
                 };
                 this.setCachedResults(cacheKey, searchResult);
+                logger.log(`🔍 Search completed after ${searchAttempts} attempts: ${limitedMessages.length} final results`);
+                if (limitedMessages.length === 0) {
+                    logger.log(`❌ No results found despite ${searchAttempts} search strategies. Consider broadening search criteria.`);
+                }
                 return searchResult;
             }
             catch (error) {
-                logger.error('Error in email search:', error);
-                throw error;
+                logger.error('Error in persistent email search:', error);
+                // Final fallback - get some recent emails and filter them
+                logger.log('🔄 Final fallback: getting recent emails to filter manually');
+                return await this.performBasicSearch(criteria);
             }
         }, 'searchEmails');
     }
     /**
-     * Apply manual filtering to search results (used when $filter can't be used with $search)
+     * Use Microsoft Graph Search API for full-text search
      */
-    applyManualFiltering(messages, criteria) {
+    async performGraphSearch(query, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const searchRequest = {
+                requests: [
+                    {
+                        entityTypes: ['message'],
+                        query: {
+                            queryString: query
+                        },
+                        from: 0,
+                        size: Math.min(maxResults, 1000), // Graph Search max is 1000
+                        fields: ['id', 'subject', 'from', 'toRecipients', 'ccRecipients', 'receivedDateTime', 'sentDateTime', 'bodyPreview', 'isRead', 'hasAttachments', 'importance', 'conversationId', 'parentFolderId', 'webLink']
+                    }
+                ]
+            };
+            const result = await graphClient
+                .api('/search/query')
+                .post(searchRequest);
+            const messages = [];
+            if (result.value?.[0]?.hitsContainers?.[0]?.hits) {
+                for (const hit of result.value[0].hitsContainers[0].hits) {
+                    const email = hit.resource;
+                    messages.push(this.mapEmailResult(email));
+                }
+            }
+            logger.log(`📧 Graph Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Graph Search failed: ${error}. Falling back to alternative search.`);
+            return [];
+        }
+    }
+    /**
+     * Build KQL (Keyword Query Language) for advanced searches
+     */
+    buildKQLQuery(criteria) {
+        const kqlParts = [];
+        if (criteria.from) {
+            // Smart sender search - handles partial names, emails, display names
+            const fromTerm = criteria.from.trim();
+            if (fromTerm.includes('@')) {
+                kqlParts.push(`from:${fromTerm}`);
+            }
+            else {
+                // For names, search in both from field and sender
+                kqlParts.push(`(from:"${fromTerm}" OR sender:"${fromTerm}" OR from:*${fromTerm}*)`);
+            }
+        }
+        if (criteria.to) {
+            kqlParts.push(`to:${criteria.to}`);
+        }
+        if (criteria.cc) {
+            kqlParts.push(`cc:${criteria.cc}`);
+        }
+        if (criteria.subject) {
+            kqlParts.push(`subject:"${criteria.subject}"`);
+        }
+        if (criteria.hasAttachment === true) {
+            kqlParts.push('hasattachment:true');
+        }
+        else if (criteria.hasAttachment === false) {
+            kqlParts.push('hasattachment:false');
+        }
+        if (criteria.isUnread === true) {
+            kqlParts.push('isread:false');
+        }
+        else if (criteria.isUnread === false) {
+            kqlParts.push('isread:true');
+        }
+        if (criteria.importance) {
+            kqlParts.push(`importance:${criteria.importance}`);
+        }
+        if (criteria.after) {
+            const afterDate = new Date(criteria.after).toISOString().split('T')[0];
+            kqlParts.push(`received>=${afterDate}`);
+        }
+        if (criteria.before) {
+            const beforeDate = new Date(criteria.before).toISOString().split('T')[0];
+            kqlParts.push(`received<=${beforeDate}`);
+        }
+        if (criteria.folder) {
+            kqlParts.push(`foldernames:"${criteria.folder}"`);
+        }
+        return kqlParts.join(' AND ');
+    }
+    /**
+     * Perform KQL-based search using Graph Search API
+     */
+    async performKQLSearch(kqlQuery, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const searchRequest = {
+                requests: [
+                    {
+                        entityTypes: ['message'],
+                        query: {
+                            queryString: kqlQuery
+                        },
+                        from: 0,
+                        size: Math.min(maxResults, 1000),
+                        fields: ['id', 'subject', 'from', 'toRecipients', 'ccRecipients', 'receivedDateTime', 'sentDateTime', 'bodyPreview', 'isRead', 'hasAttachments', 'importance', 'conversationId', 'parentFolderId', 'webLink']
+                    }
+                ]
+            };
+            const result = await graphClient
+                .api('/search/query')
+                .post(searchRequest);
+            const messages = [];
+            if (result.value?.[0]?.hitsContainers?.[0]?.hits) {
+                for (const hit of result.value[0].hitsContainers[0].hits) {
+                    const email = hit.resource;
+                    messages.push(this.mapEmailResult(email));
+                }
+            }
+            logger.log(`📧 KQL Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ KQL Search failed: ${error}. Falling back to filter search.`);
+            return [];
+        }
+    }
+    /**
+     * Fallback to OData filter-based search
+     */
+    async performFilteredSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            let apiCall = graphClient
+                .api('/me/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(Math.min(maxResults, 999));
+            // Apply OData filters where possible
+            const filters = [];
+            if (criteria.from && criteria.from.includes('@')) {
+                filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+            }
+            if (criteria.to && criteria.to.includes('@')) {
+                filters.push(`toRecipients/any(r: r/emailAddress/address eq '${criteria.to}')`);
+            }
+            if (criteria.isUnread !== undefined) {
+                filters.push(`isRead eq ${!criteria.isUnread}`);
+            }
+            if (criteria.hasAttachment !== undefined) {
+                filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
+            }
+            if (criteria.importance) {
+                filters.push(`importance eq '${criteria.importance}'`);
+            }
+            if (filters.length > 0) {
+                apiCall = apiCall.filter(filters.join(' and '));
+            }
+            // Apply folder filter using specific folder API
+            if (criteria.folder) {
+                const folders = await this.findFolderByName(criteria.folder);
+                if (folders.length > 0) {
+                    apiCall = graphClient
+                        .api(`/me/mailFolders/${folders[0].id}/messages`)
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .orderby('receivedDateTime desc')
+                        .top(Math.min(maxResults, 999));
+                }
+            }
+            const result = await apiCall.get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            logger.log(`📧 Filtered Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Filtered Search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Fallback to basic search (original implementation)
+     */
+    async performBasicSearch(criteria) {
+        logger.log('🔄 Using fallback basic search');
+        const graphClient = await this.getGraphClient();
+        const result = await 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)
+            .get();
+        let messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+        messages = this.applyManualFiltering(messages, criteria);
+        return {
+            messages,
+            hasMore: !!result['@odata.nextLink']
+        };
+    }
+    /**
+     * Map email result to EmailInfo format
+     */
+    mapEmailResult(email) {
+        return {
+            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 || '',
+            attachments: []
+        };
+    }
+    /**
+     * Remove duplicate messages based on ID
+     */
+    removeDuplicateMessages(messages) {
+        const seen = new Set();
         return messages.filter(message => {
-            // Apply text search filters manually
+            if (seen.has(message.id)) {
+                return false;
+            }
+            seen.add(message.id);
+            return true;
+        });
+    }
+    /**
+     * Apply advanced filtering with better logic
+     */
+    applyAdvancedFiltering(messages, criteria) {
+        return messages.filter(message => {
+            // Enhanced text search across multiple fields
             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))
+                const searchText = criteria.query.toLowerCase().trim();
+                const searchableContent = [
+                    message.subject,
+                    message.bodyPreview,
+                    message.from.name,
+                    message.from.address,
+                    ...message.toRecipients.map(r => `${r.name} ${r.address}`),
+                    ...message.ccRecipients.map(r => `${r.name} ${r.address}`)
+                ].join(' ').toLowerCase();
+                // Support multiple search terms (AND logic)
+                const searchTerms = searchText.split(/\s+/).filter(term => term.length > 0);
+                if (!searchTerms.every(term => searchableContent.includes(term))) {
                     return false;
+                }
             }
+            // Enhanced sender search
             if (criteria.from) {
                 const searchTerm = criteria.from.toLowerCase().trim();
                 const fromName = message.from.name.toLowerCase();
                 const fromAddress = message.from.address.toLowerCase();
-                // Multiple matching strategies for better partial name support
                 const matches = [
-                    // Direct name or email match
                     fromName.includes(searchTerm),
                     fromAddress.includes(searchTerm),
-                    // Split search term and check if all parts exist in name
+                    // Split name search
                     searchTerm.split(/\s+/).every(part => fromName.includes(part)),
-                    // Check if any word in the name starts with the search term
-                    fromName.split(/\s+/).some(namePart => namePart.startsWith(searchTerm)),
-                    // Check if search term matches any word in the name exactly
-                    fromName.split(/\s+/).some(namePart => namePart === searchTerm),
-                    // Handle "Last, First" format
-                    fromName.replace(/,\s*/g, ' ').includes(searchTerm),
-                    // Handle initials (e.g., "M Kumar" for "Madan Kumar")
-                    searchTerm.split(/\s+/).length === 2 &&
-                        fromName.split(/\s+/).length >= 2 &&
-                        fromName.split(/\s+/)[0].startsWith(searchTerm.split(/\s+/)[0][0]) &&
-                        fromName.includes(searchTerm.split(/\s+/)[1])
+                    // Word boundary search
+                    new RegExp(`\\b${searchTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'i').test(fromName),
+                    // Email domain search
+                    searchTerm.includes('@') && fromAddress === searchTerm,
+                    // Partial email search
+                    !searchTerm.includes('@') && fromAddress.includes(searchTerm)
                 ];
                 if (!matches.some(match => match))
                     return false;
             }
-            if (criteria.to) {
-                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase() === 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() === 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);
+            // Date range filters
+            if (criteria.after || criteria.before) {
                 const messageDate = new Date(message.receivedDateTime);
-                if (messageDate > beforeDate)
-                    return false;
+                if (criteria.after) {
+                    const afterDate = new Date(criteria.after);
+                    if (messageDate < afterDate)
+                        return false;
+                }
+                if (criteria.before) {
+                    const beforeDate = new Date(criteria.before);
+                    if (messageDate > beforeDate)
+                        return false;
+                }
             }
-            // Apply attachment filter
-            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment) {
+            // Other filters remain the same but are more robust
+            if (criteria.to && !message.toRecipients.some(r => r.address.toLowerCase().includes(criteria.to.toLowerCase())))
                 return false;
-            }
-            // Apply read status filter
-            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread) {
+            if (criteria.cc && (!message.ccRecipients || !message.ccRecipients.some(r => r.address.toLowerCase().includes(criteria.cc.toLowerCase()))))
                 return false;
-            }
-            // Apply importance filter
-            if (criteria.importance && message.importance !== criteria.importance) {
+            if (criteria.subject && !message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
+                return false;
+            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment)
+                return false;
+            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread)
+                return false;
+            if (criteria.importance && message.importance !== criteria.importance)
                 return false;
-            }
             return true;
         });
     }
+    /**
+     * Sort search results by relevance and date
+     */
+    sortSearchResults(messages, criteria) {
+        return messages.sort((a, b) => {
+            // Calculate relevance score
+            const scoreA = this.calculateRelevanceScore(a, criteria);
+            const scoreB = this.calculateRelevanceScore(b, criteria);
+            if (scoreA !== scoreB) {
+                return scoreB - scoreA; // Higher score first
+            }
+            // If relevance is same, sort by date (newer first)
+            return new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime();
+        });
+    }
+    /**
+     * Calculate relevance score for search results
+     */
+    calculateRelevanceScore(message, criteria) {
+        let score = 0;
+        if (criteria.query) {
+            const query = criteria.query.toLowerCase();
+            // Subject matches get higher score
+            if (message.subject.toLowerCase().includes(query))
+                score += 10;
+            // Sender name matches
+            if (message.from.name.toLowerCase().includes(query))
+                score += 5;
+            // Body preview matches
+            if (message.bodyPreview.toLowerCase().includes(query))
+                score += 3;
+            // Exact word matches get bonus
+            const words = query.split(/\s+/);
+            words.forEach(word => {
+                if (message.subject.toLowerCase().includes(word))
+                    score += 2;
+            });
+        }
+        // Recent emails get slight boost
+        const daysOld = (Date.now() - new Date(message.receivedDateTime).getTime()) / (1000 * 60 * 60 * 24);
+        if (daysOld < 7)
+            score += 2;
+        else if (daysOld < 30)
+            score += 1;
+        // Unread emails get boost
+        if (!message.isRead)
+            score += 1;
+        // Important emails get boost
+        if (message.importance === 'high')
+            score += 3;
+        return score;
+    }
     /**
      * List emails in a folder
      */
@@ -732,14 +1289,108 @@ export class MS365Operations {
         }
     }
     /**
-     * List mail folders
+     * List mail folders including child folders recursively
      */
     async listFolders() {
         try {
             const graphClient = await this.getGraphClient();
+            const allFolders = [];
+            // Get top-level folders
+            logger.log('📁 Fetching top-level mail folders...');
             const result = await graphClient
                 .api('/me/mailFolders')
                 .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .top(999) // Request up to 999 folders to avoid pagination
+                .get();
+            logger.log(`📁 Found ${result.value?.length || 0} top-level folders from API`);
+            // Process top-level folders
+            const topLevelFolders = result.value?.map((folder) => ({
+                id: folder.id,
+                displayName: folder.displayName || '',
+                totalItemCount: folder.totalItemCount || 0,
+                unreadItemCount: folder.unreadItemCount || 0,
+                parentFolderId: folder.parentFolderId,
+                depth: 0,
+                fullPath: folder.displayName || ''
+            })) || [];
+            logger.log(`📁 Processed ${topLevelFolders.length} top-level folders: ${topLevelFolders.map((f) => f.displayName).join(', ')}`);
+            allFolders.push(...topLevelFolders);
+            // Recursively get child folders for each top-level folder
+            logger.log('📂 Starting recursive child folder discovery...');
+            for (const folder of topLevelFolders) {
+                logger.log(`📂 Checking children of: ${folder.displayName} (${folder.id})`);
+                const childFolders = await this.getChildFolders(folder.id, folder.fullPath || folder.displayName, 1);
+                logger.log(`📂 Found ${childFolders.length} child folders for ${folder.displayName}`);
+                allFolders.push(...childFolders);
+            }
+            logger.log(`📁 Total folders discovered: ${allFolders.length}`);
+            // Sort folders by full path for better organization
+            allFolders.sort((a, b) => (a.fullPath || '').localeCompare(b.fullPath || ''));
+            return allFolders;
+        }
+        catch (error) {
+            logger.error('Error listing folders:', error);
+            throw error;
+        }
+    }
+    /**
+     * Recursively get child folders of a parent folder
+     */
+    async getChildFolders(parentFolderId, parentPath, depth) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const childFolders = [];
+            logger.log(`📂 [Depth ${depth}] Getting child folders for: ${parentPath} (${parentFolderId})`);
+            // Get child folders of the specified parent
+            const result = await graphClient
+                .api(`/me/mailFolders/${parentFolderId}/childFolders`)
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .top(999) // Request up to 999 child folders to avoid pagination
+                .get();
+            logger.log(`📂 [Depth ${depth}] API returned ${result.value?.length || 0} child folders for ${parentPath}`);
+            if (result.value && result.value.length > 0) {
+                const folders = result.value.map((folder) => ({
+                    id: folder.id,
+                    displayName: folder.displayName || '',
+                    totalItemCount: folder.totalItemCount || 0,
+                    unreadItemCount: folder.unreadItemCount || 0,
+                    parentFolderId: folder.parentFolderId,
+                    depth,
+                    fullPath: `${parentPath}/${folder.displayName || ''}`
+                }));
+                logger.log(`📂 [Depth ${depth}] Mapped child folders: ${folders.map((f) => f.displayName).join(', ')}`);
+                childFolders.push(...folders);
+                // Recursively get child folders (limit depth to prevent infinite recursion)
+                if (depth < 10) { // Max depth of 10 levels
+                    logger.log(`📂 [Depth ${depth}] Recursing into ${folders.length} child folders...`);
+                    for (const folder of folders) {
+                        const subChildFolders = await this.getChildFolders(folder.id, folder.fullPath || folder.displayName, depth + 1);
+                        childFolders.push(...subChildFolders);
+                    }
+                }
+                else {
+                    logger.log(`📂 [Depth ${depth}] Maximum depth reached, stopping recursion`);
+                }
+            }
+            logger.log(`📂 [Depth ${depth}] Returning ${childFolders.length} total child folders for ${parentPath}`);
+            return childFolders;
+        }
+        catch (error) {
+            // Log the error but don't throw - some folders might not have children or access might be restricted
+            logger.log(`❌ [Depth ${depth}] Could not access child folders for ${parentFolderId} (${parentPath}): ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * List child folders of a specific parent folder
+     */
+    async listChildFolders(parentFolderId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const result = await graphClient
+                .api(`/me/mailFolders/${parentFolderId}/childFolders`)
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .top(999) // Request up to 999 child folders to avoid pagination
                 .get();
             return result.value?.map((folder) => ({
                 id: folder.id,
@@ -750,7 +1401,22 @@ export class MS365Operations {
             })) || [];
         }
         catch (error) {
-            logger.error('Error listing folders:', error);
+            logger.error(`Error listing child folders for ${parentFolderId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Find folder by name (case-insensitive search across all folders)
+     */
+    async findFolderByName(folderName) {
+        try {
+            const allFolders = await this.listFolders();
+            const searchName = folderName.toLowerCase();
+            return allFolders.filter(folder => folder.displayName.toLowerCase().includes(searchName) ||
+                (folder.fullPath && folder.fullPath.toLowerCase().includes(searchName)));
+        }
+        catch (error) {
+            logger.error(`Error finding folder by name ${folderName}:`, error);
             throw error;
         }
     }
@@ -1028,5 +1694,286 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Debug method to check raw folder API response
+     */
+    async debugFolders() {
+        try {
+            const graphClient = await this.getGraphClient();
+            logger.log('🔍 DEBUG: Testing folder API calls...');
+            // Test basic folder listing
+            const basicResult = await graphClient
+                .api('/me/mailFolders')
+                .get();
+            logger.log(`🔍 DEBUG: Raw /me/mailFolders response: ${JSON.stringify(basicResult, null, 2)}`);
+            // Test with specific selection
+            const selectResult = await graphClient
+                .api('/me/mailFolders')
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .get();
+            logger.log(`🔍 DEBUG: Selected fields response: ${JSON.stringify(selectResult, null, 2)}`);
+            // Test well-known folder access
+            try {
+                const inboxResult = await graphClient
+                    .api('/me/mailFolders/inbox/childFolders')
+                    .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                    .get();
+                logger.log(`🔍 DEBUG: Inbox children: ${JSON.stringify(inboxResult, null, 2)}`);
+            }
+            catch (inboxError) {
+                logger.log(`🔍 DEBUG: Inbox children error: ${inboxError}`);
+            }
+        }
+        catch (error) {
+            logger.error('🔍 DEBUG: Error in debugFolders:', 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 searchTerm = criteria.from.toLowerCase().trim();
+                const fromName = message.from.name.toLowerCase();
+                const fromAddress = message.from.address.toLowerCase();
+                const matches = [
+                    fromName.includes(searchTerm),
+                    fromAddress.includes(searchTerm),
+                    searchTerm.split(/\s+/).every(part => fromName.includes(part)),
+                    fromName.split(/\s+/).some(namePart => namePart.startsWith(searchTerm))
+                ];
+                if (!matches.some(match => match))
+                    return false;
+            }
+            if (criteria.to) {
+                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase() === criteria.to.toLowerCase());
+                if (!toMatch)
+                    return false;
+            }
+            if (criteria.cc) {
+                const ccMatch = message.ccRecipients && message.ccRecipients.length > 0 &&
+                    message.ccRecipients.some(recipient => recipient.address.toLowerCase() === criteria.cc.toLowerCase());
+                if (!ccMatch)
+                    return false;
+            }
+            if (criteria.subject) {
+                if (!message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
+                    return false;
+            }
+            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;
+            }
+            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment) {
+                return false;
+            }
+            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread) {
+                return false;
+            }
+            if (criteria.importance && message.importance !== criteria.importance) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Build relaxed KQL query with fewer constraints
+     */
+    buildRelaxedKQLQuery(criteria) {
+        const kqlParts = [];
+        // Only include the most important criteria for relaxed search
+        if (criteria.from) {
+            const fromTerm = criteria.from.trim();
+            if (fromTerm.includes('@')) {
+                // For email addresses, try domain search too
+                const domain = fromTerm.split('@')[1];
+                if (domain) {
+                    kqlParts.push(`(from:${fromTerm} OR from:*@${domain})`);
+                }
+                else {
+                    kqlParts.push(`from:${fromTerm}`);
+                }
+            }
+            else {
+                // For names, use wildcard search
+                kqlParts.push(`from:*${fromTerm}*`);
+            }
+        }
+        if (criteria.subject) {
+            // Use partial subject matching
+            kqlParts.push(`subject:*${criteria.subject}*`);
+        }
+        // Skip attachment and read status filters in relaxed mode
+        // Keep only critical filters
+        if (criteria.importance === 'high') {
+            kqlParts.push(`importance:high`);
+        }
+        // Expand date range for relaxed search
+        if (criteria.after) {
+            const afterDate = new Date(criteria.after);
+            afterDate.setDate(afterDate.getDate() - 7); // Expand by a week
+            const expandedDate = afterDate.toISOString().split('T')[0];
+            kqlParts.push(`received>=${expandedDate}`);
+        }
+        return kqlParts.join(' AND ');
+    }
+    /**
+     * Perform partial text search across recent emails with broader matching
+     */
+    async performPartialTextSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Get a large set of recent emails to search through
+            const result = await graphClient
+                .api('/me/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(Math.min(maxResults, 1000))
+                .get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            // Apply very broad partial matching
+            const partialMatches = messages.filter(message => {
+                let matches = true;
+                // Very flexible text search
+                if (criteria.query) {
+                    const searchTerms = criteria.query.toLowerCase().split(/\s+/);
+                    const searchableText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                    // At least 50% of search terms should match
+                    const matchingTerms = searchTerms.filter(term => searchableText.includes(term));
+                    matches = matchingTerms.length >= Math.ceil(searchTerms.length * 0.5);
+                }
+                // Very flexible sender search
+                if (criteria.from && matches) {
+                    const fromTerm = criteria.from.toLowerCase();
+                    const fromText = `${message.from.name} ${message.from.address}`.toLowerCase();
+                    // Partial matching with character-level similarity
+                    matches = fromText.includes(fromTerm) ||
+                        fromTerm.split('').some(char => fromText.includes(char)) ||
+                        this.calculateStringSimilarity(fromTerm, fromText) > 0.3;
+                }
+                return matches;
+            });
+            logger.log(`📧 Partial text search found ${partialMatches.length} potential matches`);
+            return partialMatches;
+        }
+        catch (error) {
+            logger.log(`❌ Partial text search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Ultra-relaxed search that casts a very wide net
+     */
+    async performUltraRelaxedSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Search across multiple folders and time ranges
+            const searches = [];
+            // Search recent emails
+            searches.push(graphClient
+                .api('/me/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(500)
+                .get());
+            // Search sent items if looking for specific people
+            if (criteria.from || criteria.to) {
+                searches.push(graphClient
+                    .api('/me/mailFolders/sentitems/messages')
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                    .orderby('receivedDateTime desc')
+                    .top(200)
+                    .get());
+            }
+            const results = await Promise.allSettled(searches);
+            const allEmails = [];
+            results.forEach((result, index) => {
+                if (result.status === 'fulfilled') {
+                    const emails = result.value.value?.map((email) => this.mapEmailResult(email)) || [];
+                    allEmails.push(...emails);
+                    logger.log(`📧 Ultra-relaxed search ${index + 1} found ${emails.length} emails`);
+                }
+            });
+            return this.removeDuplicateMessages(allEmails);
+        }
+        catch (error) {
+            logger.log(`❌ Ultra-relaxed search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Ultra-relaxed filtering with very permissive matching
+     */
+    applyUltraRelaxedFiltering(messages, criteria) {
+        return messages.filter(message => {
+            let score = 0;
+            let hasAnyMatch = false;
+            // Any partial query match
+            if (criteria.query) {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name}`.toLowerCase();
+                // Check for any word matches
+                const queryWords = searchText.split(/\s+/);
+                const matchingWords = queryWords.filter(word => messageText.includes(word));
+                if (matchingWords.length > 0) {
+                    hasAnyMatch = true;
+                    score += matchingWords.length;
+                }
+            }
+            // Any sender similarity
+            if (criteria.from) {
+                const fromTerm = criteria.from.toLowerCase();
+                const fromText = `${message.from.name} ${message.from.address}`.toLowerCase();
+                if (fromText.includes(fromTerm) ||
+                    this.calculateStringSimilarity(fromTerm, fromText) > 0.2) {
+                    hasAnyMatch = true;
+                    score += 2;
+                }
+            }
+            // Any subject similarity
+            if (criteria.subject) {
+                const subjectTerm = criteria.subject.toLowerCase();
+                if (message.subject.toLowerCase().includes(subjectTerm)) {
+                    hasAnyMatch = true;
+                    score += 3;
+                }
+            }
+            // If no specific criteria, return recent emails
+            if (!criteria.query && !criteria.from && !criteria.subject) {
+                hasAnyMatch = true;
+            }
+            return hasAnyMatch;
+        }).sort((a, b) => {
+            // Sort by date for ultra-relaxed results
+            return new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime();
+        });
+    }
+    /**
+     * Calculate string similarity (simple version)
+     */
+    calculateStringSimilarity(str1, str2) {
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0)
+            return 1.0;
+        const matches = shorter.split('').filter(char => longer.includes(char)).length;
+        return matches / longer.length;
+    }
 }
 export const ms365Operations = new MS365Operations();