ms365-mcp-server 1.1.3 → 1.1.5

package/README.md

@@ -252,6 +252,46 @@ ms365-mcp-server --login
 }
 ```
 
+### Attachment Management
+```javascript
+// Download a specific attachment
+{
+  "tool": "get_attachment",
+  "arguments": {
+    "messageId": "email_id",
+    "attachmentId": "attachment_id"
+  }
+}
+
+// Download all attachments from an email
+{
+  "tool": "get_attachment",
+  "arguments": {
+    "messageId": "email_id"
+  }
+}
+```
+
+### File Serving
+The server automatically serves downloaded attachments. By default, files are served at `http://localhost:55000/attachments/`. For production environments, configure the server URL using the `SERVER_URL` environment variable:
+
+```bash
+# Local development (default)
+SERVER_URL=http://localhost:55000 ms365-mcp-server
+
+# Production environment
+SERVER_URL=https://your-domain.com ms365-mcp-server
+```
+
+Files are:
+- Stored with unique names to prevent collisions
+- Available for 24 hours
+- Served with proper content types
+- Accessible via the configured server URL
+
+### Cleanup
+Attachments are automatically cleaned up after 24 hours. You can also manually delete files from the `public/attachments` directory.
+
 ## 🎯 Command Line Options
 
 ```bash

package/dist/index.js

@@ -4,6 +4,11 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import express from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs/promises';
+import crypto from 'crypto';
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from './utils/api.js';
 import { MS365Operations } from './utils/ms365-operations.js';
@@ -55,7 +60,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.3"
+    version: "1.1.5"
 }, {
     capabilities: {
         resources: {
@@ -835,8 +840,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const graphClient = await enhancedMS365Auth.getGraphClient();
                     ms365Ops.setGraphClient(graphClient);
                 }
-                if (!args?.messageId || !args?.attachmentId) {
-                    throw new Error("Both messageId and attachmentId are required");
+                if (!args?.messageId) {
+                    throw new Error("messageId is required");
                 }
                 try {
                     // First verify the email exists and has attachments
@@ -847,25 +852,47 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     if (!email.attachments || email.attachments.length === 0) {
                         throw new Error("No attachment information available for this email");
                     }
-                    // Verify the requested attachment exists
-                    const attachmentExists = email.attachments.some(att => att.id === args.attachmentId);
-                    if (!attachmentExists) {
-                        throw new Error(`Attachment ID ${args.attachmentId} not found in this email. Available attachments:\n${email.attachments.map(att => `- ${att.name} (ID: ${att.id})`).join('\n')}`);
+                    // If specific attachmentId is provided, get that attachment
+                    if (args?.attachmentId) {
+                        const attachmentExists = email.attachments.some(att => att.id === args.attachmentId);
+                        if (!attachmentExists) {
+                            throw new Error(`Attachment ID ${args.attachmentId} not found in this email. Available attachments:\n${email.attachments.map(att => `- ${att.name} (ID: ${att.id})`).join('\n')}`);
+                        }
+                        const attachment = await ms365Ops.getAttachment(args.messageId, args.attachmentId);
+                        // Save the attachment to file
+                        const savedFilename = await saveBase64ToFile(attachment.contentBytes, attachment.name);
+                        const fileUrl = `${SERVER_URL}/attachments/${savedFilename}`;
+                        attachment.fileUrl = fileUrl;
+                        const artifacts = getListOfArtifacts("get_attachment", [attachment]);
+                        const content = {
+                            type: "text",
+                            text: `📎 Attachment Downloaded\n\n📁 Name: ${attachment.name}\n💾 Size: ${attachment.size} bytes\n🗂️ Type: ${attachment.contentType}\n\n🔗 Download URL: ${fileUrl}\n\n💡 The file will be available for 24 hours.`
+                        };
+                        return {
+                            content: [content, ...artifacts]
+                        };
+                    }
+                    else {
+                        // Get all attachments
+                        const attachments = await Promise.all(email.attachments.map(async (att) => {
+                            const attachment = await ms365Ops.getAttachment(args.messageId, att.id);
+                            const savedFilename = await saveBase64ToFile(attachment.contentBytes, attachment.name);
+                            return {
+                                name: attachment.name,
+                                contentType: attachment.contentType,
+                                size: attachment.size,
+                                fileUrl: `${SERVER_URL}/attachments/${savedFilename}`
+                            };
+                        }));
+                        const artifacts = getListOfArtifacts("get_attachment", attachments);
+                        const content = {
+                            type: "text",
+                            text: `📎 Downloaded ${attachments.length} Attachments\n\n${attachments.map((att, index) => `${index + 1}. 📁 ${att.name}\n   💾 Size: ${att.size} bytes\n   🗂️ Type: ${att.contentType}\n   🔗 Download URL: ${att.fileUrl}\n`).join('\n')}\n\n💡 Files will be available for 24 hours.`
+                        };
+                        return {
+                            content: [content, ...artifacts]
+                        };
                     }
-                    // Now get the attachment
-                    const attachment = await ms365Ops.getAttachment(args.messageId, args.attachmentId);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `📎 Attachment Downloaded\n\n📁 Name: ${attachment.name}\n💾 Size: ${attachment.size} bytes\n🗂️ Type: ${attachment.contentType}\n\nBelow is the base64-encoded content. You can save this to a file using a script or tool that decodes base64.\n\n---BASE64 START---\n${attachment.contentBytes}\n---BASE64 END---`
-                            }
-                        ],
-                        base64Content: attachment.contentBytes,
-                        filename: attachment.name,
-                        contentType: attachment.contentType,
-                        size: attachment.size
-                    };
                 }
                 catch (error) {
                     if (error.message.includes("not found in the store")) {
@@ -942,6 +969,140 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
 });
+function generateAlphaNumericId(alphaSize = 3, numericSize = 3) {
+    const letters = 'abcdefghijklmnopqrstuvwxyz';
+    const digits = '0123456789';
+    let alphaPart = '';
+    let numericPart = '';
+    for (let i = 0; i < alphaSize; i++) {
+        alphaPart += letters.charAt(Math.floor(Math.random() * letters.length));
+    }
+    for (let i = 0; i < numericSize; i++) {
+        numericPart += digits.charAt(Math.floor(Math.random() * digits.length));
+    }
+    return alphaPart + numericPart;
+}
+function getListOfArtifacts(functionName, attachments) {
+    const artifacts = [];
+    attachments.forEach((attachment, i) => {
+        const url = attachment?.fileUrl || '';
+        const fileName = attachment?.name || '';
+        if (url) {
+            const timestamp = Math.floor(Date.now() / 1000); // seconds
+            const visitTimestamp = Date.now(); // milliseconds
+            const artifactData = {
+                id: `msg_browser_${generateAlphaNumericId()}`,
+                parentTaskId: `task_attachment_${generateAlphaNumericId()}`,
+                timestamp: timestamp,
+                agent: {
+                    id: "agent_siya_browser",
+                    name: "SIYA",
+                    type: "qna"
+                },
+                messageType: "action",
+                action: {
+                    tool: "browser",
+                    operation: "browsing",
+                    params: {
+                        url: `Filename: ${fileName}`,
+                        pageTitle: `Tool response for ${functionName}`,
+                        visual: {
+                            icon: "browser",
+                            color: "#2D8CFF"
+                        },
+                        stream: {
+                            type: "vnc",
+                            streamId: "stream_browser_1",
+                            target: "browser"
+                        }
+                    }
+                },
+                content: `Viewed page: ${functionName}`,
+                artifacts: [
+                    {
+                        id: "artifact_webpage_1746018877304_994",
+                        type: "browser_view",
+                        content: {
+                            url: url,
+                            title: functionName,
+                            screenshot: "",
+                            textContent: `Observed output of cmd \`${functionName}\` executed:`,
+                            extractedInfo: {}
+                        },
+                        metadata: {
+                            domainName: "example.com",
+                            visitTimestamp: visitTimestamp,
+                            category: "web_page"
+                        }
+                    }
+                ],
+                status: "completed"
+            };
+            const artifact = {
+                type: "text",
+                text: JSON.stringify(artifactData, null, 2),
+                title: `Filename: ${fileName}`,
+                format: "json"
+            };
+            artifacts.push(artifact);
+        }
+    });
+    return artifacts;
+}
+// Set up Express server for file serving
+const app = express();
+const PORT = process.env.PORT || 55000;
+const SERVER_URL = process.env.SERVER_URL || `http://localhost:${PORT}`;
+// Get the directory name in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Serve static files from public directory
+app.use('/attachments', express.static(path.join(__dirname, '../public/attachments')));
+// Start Express server
+app.listen(PORT, () => {
+    logger.log(`File server running on ${SERVER_URL}`);
+});
+// Helper function to generate unique filenames
+function generateUniqueFilename(originalName) {
+    const timestamp = Date.now();
+    const randomString = crypto.randomBytes(8).toString('hex');
+    const extension = path.extname(originalName);
+    const baseName = path.basename(originalName, extension).replace(/[^a-zA-Z0-9-_]/g, '_');
+    return `${baseName}-${timestamp}-${randomString}${extension}`;
+}
+// Helper function to save base64 content to file
+async function saveBase64ToFile(base64Content, filename) {
+    const uniqueFilename = generateUniqueFilename(filename);
+    const filePath = path.join(__dirname, '../public/attachments', uniqueFilename);
+    const buffer = Buffer.from(base64Content, 'base64');
+    await fs.writeFile(filePath, buffer);
+    return uniqueFilename;
+}
+// Helper function to clean up old attachments
+async function cleanupOldAttachments() {
+    const attachmentsDir = path.join(__dirname, '../public/attachments');
+    try {
+        const files = await fs.readdir(attachmentsDir);
+        const now = Date.now();
+        for (const file of files) {
+            const filePath = path.join(attachmentsDir, file);
+            const stats = await fs.stat(filePath);
+            const fileAge = now - stats.mtimeMs;
+            // Remove files older than 24 hours
+            if (fileAge > 24 * 60 * 60 * 1000) {
+                await fs.unlink(filePath);
+                logger.log(`Cleaned up old attachment: ${file}`);
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Error cleaning up attachments:', error);
+    }
+}
+// Set up cleanup interval (run every hour)
+setInterval(cleanupOldAttachments, 60 * 60 * 1000);
+// Run initial cleanup
+cleanupOldAttachments();
 async function main() {
     ms365Config = parseArgs();
     if (ms365Config.setupAuth) {

package/dist/utils/ms365-operations.js

@@ -810,33 +810,100 @@ export class MS365Operations {
     async searchEmailsToMe(additionalCriteria = {}) {
         try {
             const userEmail = await this.getCurrentUserEmail();
-            // First search for emails where user is in TO field
-            const toCriteria = {
-                ...additionalCriteria,
-                to: userEmail
-            };
-            // Then search for emails where user is in CC field
-            const ccCriteria = {
-                ...additionalCriteria,
-                cc: userEmail
-            };
-            // Execute both searches in parallel
-            const [toResults, ccResults] = await Promise.all([
-                this.searchEmails(toCriteria),
-                this.searchEmails(ccCriteria)
-            ]);
-            // Combine results and remove duplicates based on email ID
-            const allMessages = [...toResults.messages, ...ccResults.messages];
-            const uniqueMessages = allMessages.filter((message, index, array) => array.findIndex(m => m.id === message.id) === index);
-            // Sort by received date (newest first)
-            uniqueMessages.sort((a, b) => new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime());
-            // Apply maxResults limit if specified
-            const maxResults = additionalCriteria.maxResults || 50;
-            const limitedMessages = uniqueMessages.slice(0, maxResults);
-            return {
-                messages: limitedMessages,
-                hasMore: uniqueMessages.length > maxResults || toResults.hasMore || ccResults.hasMore
-            };
+            const graphClient = await this.getGraphClient();
+            // Create cache key from criteria
+            const cacheKey = JSON.stringify({ ...additionalCriteria, userEmail });
+            const cachedResults = this.getCachedResults(cacheKey);
+            if (cachedResults) {
+                return cachedResults;
+            }
+            try {
+                // Start with a basic query to get emails
+                const apiCall = graphClient.api('/me/messages')
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink');
+                // Add search query for user's email in TO or CC using proper syntax
+                apiCall.search(`"${userEmail}"`);
+                // Add simple filters that are supported by the API
+                if (additionalCriteria.after) {
+                    apiCall.filter(`receivedDateTime ge ${new Date(additionalCriteria.after).toISOString()}`);
+                }
+                if (additionalCriteria.before) {
+                    apiCall.filter(`receivedDateTime le ${new Date(additionalCriteria.before).toISOString()}`);
+                }
+                if (additionalCriteria.hasAttachment !== undefined) {
+                    apiCall.filter(`hasAttachments eq ${additionalCriteria.hasAttachment}`);
+                }
+                if (additionalCriteria.isUnread !== undefined) {
+                    apiCall.filter(`isRead eq ${!additionalCriteria.isUnread}`);
+                }
+                if (additionalCriteria.importance) {
+                    apiCall.filter(`importance eq '${additionalCriteria.importance}'`);
+                }
+                // Set page size
+                const pageSize = Math.min(additionalCriteria.maxResults || 100, 100);
+                apiCall.top(pageSize);
+                const result = await apiCall.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: []
+                })) || [];
+                // Filter messages to only include those where the user is in TO or CC
+                const filteredMessages = messages.filter(message => {
+                    const isInTo = message.toRecipients.some(recipient => recipient.address.toLowerCase() === userEmail.toLowerCase());
+                    const isInCc = message.ccRecipients.some(recipient => recipient.address.toLowerCase() === userEmail.toLowerCase());
+                    return isInTo || isInCc;
+                });
+                // Sort messages by receivedDateTime in descending order
+                filteredMessages.sort((a, b) => new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime());
+                // For emails with attachments, get attachment counts
+                for (const message of filteredMessages) {
+                    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);
+                        }
+                        catch (error) {
+                            logger.error(`Error getting attachment count for message ${message.id}:`, error);
+                            message.attachments = [];
+                        }
+                    }
+                }
+                const searchResult = {
+                    messages: filteredMessages,
+                    hasMore: !!result['@odata.nextLink']
+                };
+                this.setCachedResults(cacheKey, searchResult);
+                return searchResult;
+            }
+            catch (error) {
+                logger.error('Error in email search:', error);
+                throw error;
+            }
         }
         catch (error) {
             logger.error('Error searching emails addressed to me:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Microsoft 365 MCP Server for managing Microsoft 365 email through natural language interactions with full OAuth2 authentication support",
   "main": "dist/index.js",
   "type": "module",
@@ -30,19 +30,21 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.10.1",
     "@azure/msal-node": "^2.6.6",
     "@microsoft/microsoft-graph-client": "^3.0.7",
+    "@modelcontextprotocol/sdk": "^1.10.1",
+    "express": "^5.1.0",
     "isomorphic-fetch": "^3.0.0",
-    "open": "^10.1.0",
-    "mime-types": "^2.1.35",
     "keytar": "^7.9.0",
+    "mime-types": "^2.1.35",
+    "open": "^10.1.0",
     "typescript": "^5.0.4"
   },
   "devDependencies": {
-    "@types/node": "^20.2.3",
-    "@types/mime-types": "^2.1.4",
+    "@types/express": "^5.0.3",
     "@types/isomorphic-fetch": "^0.0.36",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^20.2.3",
     "ts-node": "^10.9.1",
     "tsx": "^4.19.4"
   },