ms365-mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,1251 @@
+/**
+ * Microsoft 365 MCP Server
+ * A comprehensive server implementation using Model Context Protocol for Microsoft 365 API
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from './utils/api.js';
+import { MS365Operations } from './utils/ms365-operations.js';
+import { multiUserMS365Auth } from './utils/multi-user-auth.js';
+import { enhancedMS365Auth } from './utils/ms365-auth-enhanced.js';
+// Create singleton MS365Operations instance
+const ms365Ops = new MS365Operations();
+let ms365Config;
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        setupAuth: false,
+        resetAuth: false,
+        debug: false,
+        nonInteractive: false,
+        multiUser: false,
+        login: false,
+        logout: false,
+        verifyLogin: false
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--setup-auth') {
+            config.setupAuth = true;
+        }
+        else if (arg === '--reset-auth') {
+            config.resetAuth = true;
+        }
+        else if (arg === '--debug' || arg === '-d') {
+            config.debug = true;
+        }
+        else if (arg === '--non-interactive' || arg === '-n') {
+            config.nonInteractive = true;
+        }
+        else if (arg === '--multi-user') {
+            config.multiUser = true;
+        }
+        else if (arg === '--login') {
+            config.login = true;
+        }
+        else if (arg === '--logout') {
+            config.logout = true;
+        }
+        else if (arg === '--verify-login') {
+            config.verifyLogin = true;
+        }
+    }
+    return config;
+}
+const server = new Server({
+    name: "ms365-mcp-server",
+    version: "1.0.0"
+}, {
+    capabilities: {
+        resources: {
+            read: true,
+            list: true
+        },
+        tools: {
+            list: true,
+            call: true
+        },
+        prompts: {
+            list: true
+        }
+    }
+});
+// Set up the resource listing request handler
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logger.log('Received list resources request');
+    return { resources: [] };
+});
+/**
+ * Handler for reading resource information.
+ */
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    logger.log('Received read resource request: ' + JSON.stringify(request));
+    throw new Error("Resource reading not implemented");
+});
+/**
+ * Handler for listing available prompts.
+ */
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    logger.log('Received list prompts request');
+    return { prompts: [] };
+});
+/**
+ * List available tools for interacting with Microsoft 365.
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const baseTools = [
+        {
+            name: "send_email",
+            description: "Send an email message with support for HTML content, attachments, and international characters. Supports both plain text and HTML emails with proper formatting.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    to: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of recipient email addresses"
+                    },
+                    cc: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of CC recipient email addresses (optional)"
+                    },
+                    bcc: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of BCC recipient email addresses (optional)"
+                    },
+                    subject: {
+                        type: "string",
+                        description: "Email subject line with full support for international characters"
+                    },
+                    body: {
+                        type: "string",
+                        description: "Email content (text or HTML based on bodyType)"
+                    },
+                    bodyType: {
+                        type: "string",
+                        enum: ["text", "html"],
+                        description: "Content type of the email body (default: text)",
+                        default: "text"
+                    },
+                    replyTo: {
+                        type: "string",
+                        description: "Reply-to email address (optional)"
+                    },
+                    importance: {
+                        type: "string",
+                        enum: ["low", "normal", "high"],
+                        description: "Email importance level (default: normal)",
+                        default: "normal"
+                    },
+                    attachments: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    description: "Name of the attachment file"
+                                },
+                                contentBytes: {
+                                    type: "string",
+                                    description: "Base64 encoded content of the attachment"
+                                },
+                                contentType: {
+                                    type: "string",
+                                    description: "MIME type of the attachment (optional, auto-detected if not provided)"
+                                }
+                            },
+                            required: ["name", "contentBytes"]
+                        },
+                        description: "List of email attachments (optional)"
+                    }
+                },
+                required: ["to", "subject"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "read_email",
+            description: "Read email message by ID with advanced content extraction. Returns full email content including headers, body, and attachment information.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    messageId: {
+                        type: "string",
+                        description: "Microsoft 365 message ID to retrieve"
+                    },
+                    includeAttachments: {
+                        type: "boolean",
+                        description: "Whether to include attachment information and content",
+                        default: false
+                    }
+                },
+                required: ["messageId"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "search_emails",
+            description: "Search emails with various criteria including subject, sender, TO/CC recipients, date range, and advanced filtering. Supports complex queries and filtering, including emails addressed to you directly or where you were CC'd.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    query: {
+                        type: "string",
+                        description: "General search query using natural language or specific terms"
+                    },
+                    from: {
+                        type: "string",
+                        description: "Search for emails from specific sender"
+                    },
+                    to: {
+                        type: "string",
+                        description: "Search for emails to specific recipient (useful for finding emails addressed to you)"
+                    },
+                    cc: {
+                        type: "string",
+                        description: "Search for emails with specific CC recipient (useful for finding emails where someone was CC'd)"
+                    },
+                    subject: {
+                        type: "string",
+                        description: "Search for emails with specific subject"
+                    },
+                    after: {
+                        type: "string",
+                        description: "Search for emails after date (format: YYYY-MM-DD)"
+                    },
+                    before: {
+                        type: "string",
+                        description: "Search for emails before date (format: YYYY-MM-DD)"
+                    },
+                    hasAttachment: {
+                        type: "boolean",
+                        description: "Filter emails that have attachments"
+                    },
+                    folder: {
+                        type: "string",
+                        description: "Search within specific folder (default: inbox)"
+                    },
+                    isUnread: {
+                        type: "boolean",
+                        description: "Filter for unread emails only"
+                    },
+                    importance: {
+                        type: "string",
+                        enum: ["low", "normal", "high"],
+                        description: "Filter by email importance level"
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum number of results to return (default: 50, max: 200)",
+                        minimum: 1,
+                        maximum: 200,
+                        default: 50
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "list_emails",
+            description: "List emails in inbox, sent, or custom folder. Returns basic email information including subjects, senders, and snippets with support for folder navigation.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    folderId: {
+                        type: "string",
+                        description: "Folder ID or name (default: inbox). Common values: inbox, sentitems, drafts, deleteditems",
+                        default: "inbox"
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum number of emails to retrieve (default: 50, max: 200)",
+                        minimum: 1,
+                        maximum: 200,
+                        default: 50
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "mark_email",
+            description: "Mark email as read or unread. Useful for managing email status and organizing your inbox.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    messageId: {
+                        type: "string",
+                        description: "Microsoft 365 message ID to mark"
+                    },
+                    isRead: {
+                        type: "boolean",
+                        description: "True to mark as read, false to mark as unread"
+                    }
+                },
+                required: ["messageId", "isRead"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "move_email",
+            description: "Move email to different folder. Supports moving emails between various Outlook folders for organization.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    messageId: {
+                        type: "string",
+                        description: "Microsoft 365 message ID to move"
+                    },
+                    destinationFolderId: {
+                        type: "string",
+                        description: "Destination folder ID or name (e.g., 'archive', 'drafts', 'deleteditems')"
+                    }
+                },
+                required: ["messageId", "destinationFolderId"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "delete_email",
+            description: "Permanently delete an email message. Use with caution as this action cannot be undone.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    messageId: {
+                        type: "string",
+                        description: "Microsoft 365 message ID to delete"
+                    }
+                },
+                required: ["messageId"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "get_attachment",
+            description: "Download and retrieve attachment information from an email. Returns attachment data, filename, and metadata.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    messageId: {
+                        type: "string",
+                        description: "Microsoft 365 message ID containing the attachment"
+                    },
+                    attachmentId: {
+                        type: "string",
+                        description: "Attachment ID to download"
+                    }
+                },
+                required: ["messageId", "attachmentId"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "list_folders",
+            description: "List all mail folders in the mailbox. Returns folder names, IDs, and item counts for navigation and organization.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "get_contacts",
+            description: "Retrieve contact list from Microsoft 365. Returns contact information including names, email addresses, and phone numbers.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum number of contacts to retrieve (default: 100, max: 500)",
+                        minimum: 1,
+                        maximum: 500,
+                        default: 100
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "search_contacts",
+            description: "Search contacts by name or email address. Useful for finding specific contacts for email addressing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    query: {
+                        type: "string",
+                        description: "Search query for contact name or email address"
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum number of contacts to return (default: 50, max: 200)",
+                        minimum: 1,
+                        maximum: 200,
+                        default: 50
+                    }
+                },
+                required: ["query"],
+                additionalProperties: false
+            }
+        }
+    ];
+    // Add multi-user specific tools
+    const multiUserTools = [
+        {
+            name: "authenticate_user",
+            description: "Start authentication flow for a new user. Returns authentication URL that user needs to visit for Microsoft 365 access.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userEmail: {
+                        type: "string",
+                        description: "User's email address (optional, for identification)"
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "get_my_session_info",
+            description: "Get information about your own authentication session (user-specific, secure).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "Your User ID to get information for"
+                    }
+                },
+                required: ["userId"],
+                additionalProperties: false
+            }
+        },
+        {
+            name: "remove_my_session",
+            description: "Remove your own authentication session (user-specific, secure).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "Your User ID to remove"
+                    }
+                },
+                required: ["userId"],
+                additionalProperties: false
+            }
+        }
+    ];
+    // Add one-time authentication tool for single-user mode
+    const oneTimeAuthTools = [
+        {
+            name: "quick_authenticate",
+            description: "One-time Microsoft 365 authentication for immediate access. Opens browser automatically and completes authentication flow.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    force: {
+                        type: "boolean",
+                        description: "Force re-authentication even if already authenticated (default: false)",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "get_auth_link",
+            description: "Get a clickable Microsoft 365 authentication link without auto-opening browser. Perfect for manual authentication control.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    force: {
+                        type: "boolean",
+                        description: "Force new authentication link even if already authenticated (default: false)",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "check_quick_auth_status",
+            description: "Check if quick authentication has completed successfully. Use this after using quick_authenticate to see if you're now authenticated.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        }
+    ];
+    // Enhanced authentication tools with device code flow
+    const enhancedAuthTools = [
+        {
+            name: "device_code_login",
+            description: "Start device code authentication flow and get the URL/code to enter. Shows authentication details immediately in the UI.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    force: {
+                        type: "boolean",
+                        description: "Force new authentication even if already authenticated (default: false)",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        },
+        {
+            name: "complete_device_code_auth",
+            description: "Check if device code authentication has completed after visiting the URL and entering the code. This is a quick status check - authentication happens automatically in the background.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        },
+        {
+            name: "check_pending_auth",
+            description: "Check if there's a pending device code authentication and get the URL/code again if needed.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        },
+        {
+            name: "get_device_code",
+            description: "Get device code information for manual authentication without starting the full flow. Returns URL and code to enter.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        },
+        {
+            name: "verify_authentication",
+            description: "Verify current authentication status and show account information. Useful for checking if authentication is still valid.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        },
+        {
+            name: "list_authenticated_accounts",
+            description: "List all authenticated Microsoft 365 accounts stored securely. Shows which accounts are available for use.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        },
+        {
+            name: "get_storage_info",
+            description: "Get information about how credentials are stored (OS Keychain vs encrypted file). Useful for security auditing.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+            }
+        },
+        {
+            name: "logout",
+            description: "Log out and clear stored authentication tokens for the current user. This will require re-authentication.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    accountKey: {
+                        type: "string",
+                        description: "Account key to logout (default: current user)",
+                        default: "default-user"
+                    }
+                },
+                additionalProperties: false
+            }
+        }
+    ];
+    if (ms365Config.multiUser) {
+        return { tools: [...baseTools, ...multiUserTools] };
+    }
+    // For single-user mode, include enhanced authentication tools
+    // Check if user is authenticated using enhanced auth system
+    const isAuthenticated = await enhancedMS365Auth.isAuthenticated();
+    if (!isAuthenticated) {
+        return { tools: [...baseTools, ...oneTimeAuthTools, ...enhancedAuthTools] };
+    }
+    // If authenticated, still provide auth management tools
+    return { tools: [...baseTools, ...enhancedAuthTools] };
+});
+/**
+ * Handle tool execution requests
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            // ============ ENHANCED AUTHENTICATION TOOLS ============
+            case "quick_authenticate":
+                if (!await enhancedMS365Auth.isAuthenticated() || args?.force) {
+                    // Use the enhanced device code flow for better UI experience
+                    const deviceCodeInfo = await enhancedMS365Auth.startDeviceCodeAuth();
+                    // Return device code info immediately, user will need to complete manually
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🔐 Microsoft 365 Authentication Required!\n\n📱 Please visit: ${deviceCodeInfo.verificationUri}\n🔑 Enter this code: ${deviceCodeInfo.userCode}\n\n⏳ Authentication is in progress. The system will automatically complete once you enter the code.\n\n💡 This code expires in 15 minutes.`
+                            }
+                        ]
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "✅ Already authenticated with Microsoft 365. Use force: true to re-authenticate."
+                            }
+                        ]
+                    };
+                }
+            case "get_auth_link":
+                if (!await enhancedMS365Auth.isAuthenticated() || args?.force) {
+                    const authUrl = await enhancedMS365Auth.getAuthUrl();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🔗 Microsoft 365 Authentication Link:\n\n${authUrl}\n\nClick this link to authenticate with Microsoft 365.`
+                            }
+                        ]
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "✅ Already authenticated with Microsoft 365. Use force: true to get a new authentication link."
+                            }
+                        ]
+                    };
+                }
+            case "check_quick_auth_status":
+                const isCurrentlyAuthenticated = await enhancedMS365Auth.isAuthenticated();
+                const hasPending = enhancedMS365Auth.hasPendingAuth();
+                if (isCurrentlyAuthenticated) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "✅ Quick authentication completed successfully! You can now use all Microsoft 365 email features."
+                            }
+                        ]
+                    };
+                }
+                else if (hasPending) {
+                    const pendingInfo = enhancedMS365Auth.getPendingDeviceCodeInfo();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `⏳ Authentication still pending.\n\n📱 Please visit: ${pendingInfo?.verificationUri}\n🔑 Enter code: ${pendingInfo?.userCode}\n\n💡 Check again after entering the code in your browser. Authentication completes automatically - no need to wait or use additional tools.`
+                            }
+                        ]
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "❌ No authentication found. Please use quick_authenticate to start the authentication process."
+                            }
+                        ]
+                    };
+                }
+            case "device_code_login":
+                if (!await enhancedMS365Auth.isAuthenticated() || args?.force) {
+                    const deviceCodeInfo = await enhancedMS365Auth.startDeviceCodeAuth();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🔐 Microsoft 365 Device Code Authentication Started!\n\n📱 Visit: ${deviceCodeInfo.verificationUri}\n🔑 Enter this code: ${deviceCodeInfo.userCode}\n\n⏳ After entering the code, use the "complete_device_code_auth" tool to finish authentication.\n\n💡 This code will expire in 15 minutes.`
+                            }
+                        ]
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "✅ Already authenticated with Microsoft 365. Use force: true to re-authenticate."
+                            }
+                        ]
+                    };
+                }
+            case "complete_device_code_auth":
+                if (!enhancedMS365Auth.hasPendingAuth()) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "❌ No pending device code authentication found. Use 'device_code_login' first to start the authentication process."
+                            }
+                        ]
+                    };
+                }
+                // Check if authentication has already completed (non-blocking)
+                const isNowAuthenticated = await enhancedMS365Auth.isAuthenticated();
+                if (isNowAuthenticated) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "✅ Device code authentication completed successfully! You can now use all Microsoft 365 email features."
+                            }
+                        ]
+                    };
+                }
+                // If still pending, return status with instructions
+                const pendingInfo = enhancedMS365Auth.getPendingDeviceCodeInfo();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `⏳ Device code authentication still in progress.\n\n📱 Please visit: ${pendingInfo?.verificationUri}\n🔑 Enter code: ${pendingInfo?.userCode}\n\n💡 Try this tool again after completing the authentication in your browser.\n\nNote: Authentication completes automatically once you enter the code - no need to wait.`
+                        }
+                    ]
+                };
+            case "check_pending_auth":
+                if (enhancedMS365Auth.hasPendingAuth()) {
+                    const pendingInfo = enhancedMS365Auth.getPendingDeviceCodeInfo();
+                    if (pendingInfo) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `⏳ Pending Device Code Authentication\n\n📱 Visit: ${pendingInfo.verificationUri}\n🔑 Enter this code: ${pendingInfo.userCode}\n\n💡 Use 'complete_device_code_auth' to finish authentication after entering the code.`
+                                }
+                            ]
+                        };
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "ℹ️ No pending device code authentication found. Use 'device_code_login' to start a new authentication process."
+                        }
+                    ]
+                };
+            case "get_device_code":
+                const deviceCodeInfo = await enhancedMS365Auth.getDeviceCodeInfo();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔐 Microsoft 365 Device Code Authentication\n\n📱 Visit: ${deviceCodeInfo.verificationUri}\n🔑 Enter code: ${deviceCodeInfo.userCode}\n\n⏳ This code will expire in 15 minutes.`
+                        }
+                    ]
+                };
+            case "verify_authentication":
+                const isAuthenticated = await enhancedMS365Auth.isAuthenticated();
+                const accounts = await enhancedMS365Auth.listAuthenticatedAccounts();
+                const storageInfo = enhancedMS365Auth.getStorageInfo();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n💾 Storage method: ${storageInfo.method}\n📁 Storage location: ${storageInfo.location}\n👥 Authenticated accounts: ${accounts.length > 0 ? accounts.join(', ') : 'None'}`
+                        }
+                    ]
+                };
+            case "list_authenticated_accounts":
+                const authenticatedAccounts = await enhancedMS365Auth.listAuthenticatedAccounts();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `👥 Authenticated Microsoft 365 Accounts:\n\n${authenticatedAccounts.length > 0 ? authenticatedAccounts.map(account => `• ${account}`).join('\n') : 'No authenticated accounts found'}`
+                        }
+                    ]
+                };
+            case "get_storage_info":
+                const storage = enhancedMS365Auth.getStorageInfo();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔒 Credential Storage Information\n\n💾 Method: ${storage.method}\n📁 Location: ${storage.location}\n🔐 Keychain Available: ${storage.method === 'OS Keychain' ? 'Yes' : 'No'}`
+                        }
+                    ]
+                };
+            case "logout":
+                const accountKey = args?.accountKey;
+                // Get list of authenticated accounts before logout for better feedback
+                const authenticatedAccountsBefore = await enhancedMS365Auth.listAuthenticatedAccounts();
+                await enhancedMS365Auth.resetAuth(accountKey);
+                // Check what was actually logged out
+                const authenticatedAccountsAfter = await enhancedMS365Auth.listAuthenticatedAccounts();
+                const loggedOutAccounts = authenticatedAccountsBefore.filter(account => !authenticatedAccountsAfter.includes(account));
+                if (accountKey) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Successfully logged out from Microsoft 365. Account: ${accountKey}`
+                            }
+                        ]
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Successfully logged out from Microsoft 365.\n${loggedOutAccounts.length > 0 ? `Logged out accounts: ${loggedOutAccounts.join(', ')}` : 'No accounts found to logout'}`
+                            }
+                        ]
+                    };
+                }
+            // ============ MULTI-USER AUTHENTICATION TOOLS ============
+            case "authenticate_user":
+                if (!ms365Config.multiUser) {
+                    throw new Error("Multi-user mode not enabled. Start server with --multi-user flag.");
+                }
+                const authResult = await multiUserMS365Auth.authenticateNewUser(args?.userEmail || undefined);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔗 Authentication started for user: ${authResult.userId}\n\n📱 Visit this URL to authenticate:\n${authResult.authUrl}\n\n⚠️ Server running on port ${authResult.port}`
+                        }
+                    ]
+                };
+            case "get_my_session_info":
+                if (!ms365Config.multiUser) {
+                    throw new Error("Multi-user mode not enabled. Start server with --multi-user flag.");
+                }
+                if (!args?.userId) {
+                    throw new Error("User ID is required");
+                }
+                const session = multiUserMS365Auth.getUserSession(args.userId);
+                if (!session) {
+                    throw new Error(`User session not found: ${args.userId}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `👤 Session Information\n\n🆔 User ID: ${session.userId}\n📧 Email: ${session.userEmail || 'Unknown'}\n🔐 Authenticated: ${session.authenticated ? 'Yes' : 'No'}\n⏰ Expires: ${new Date(session.expiresOn).toLocaleString()}`
+                        }
+                    ]
+                };
+            case "remove_my_session":
+                if (!ms365Config.multiUser) {
+                    throw new Error("Multi-user mode not enabled. Start server with --multi-user flag.");
+                }
+                if (!args?.userId) {
+                    throw new Error("User ID is required");
+                }
+                const removed = multiUserMS365Auth.removeUser(args.userId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: removed ? `✅ Session removed for user: ${args.userId}` : `❌ Session not found for user: ${args.userId}`
+                        }
+                    ]
+                };
+            // ============ EMAIL OPERATIONS ============
+            case "send_email":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const emailResult = await ms365Ops.sendEmail(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ Email sent successfully!\n\n📧 To: ${Array.isArray(args?.to) ? args.to.join(', ') : args?.to}\n📋 Subject: ${args?.subject}\n🆔 Message ID: ${emailResult.id}`
+                        }
+                    ]
+                };
+            case "read_email":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const email = await ms365Ops.getEmail(args?.messageId, args?.includeAttachments);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📧 Email Details\n\n📋 Subject: ${email.subject}\n👤 From: ${email.from.name} <${email.from.address}>\n📅 Date: ${email.receivedDateTime}\n📎 Attachments: ${email.attachments?.length || 0}\n\n💬 Body:\n${email.body || email.bodyPreview}`
+                        }
+                    ]
+                };
+            case "search_emails":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const searchResults = await ms365Ops.searchEmails(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔍 Email Search Results (${searchResults.messages.length} found)\n\n${searchResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   🆔 ID: ${email.id}\n`).join('\n')}`
+                        }
+                    ]
+                };
+            case "list_emails":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const emailList = await ms365Ops.listEmails(args?.folderId, args?.maxResults);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📬 Email List (${emailList.messages.length} emails)\n\n${emailList.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   ${email.isRead ? '📖' : '📩'} ${email.isRead ? 'Read' : 'Unread'}\n   🆔 ID: ${email.id}\n`).join('\n')}`
+                        }
+                    ]
+                };
+            case "mark_email":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                await ms365Ops.markEmail(args?.messageId, args?.isRead);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ Email marked as ${args?.isRead ? 'read' : 'unread'}\n🆔 Message ID: ${args?.messageId}`
+                        }
+                    ]
+                };
+            case "move_email":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                await ms365Ops.moveEmail(args?.messageId, args?.destinationFolderId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ Email moved to folder: ${args?.destinationFolderId}\n🆔 Message ID: ${args?.messageId}`
+                        }
+                    ]
+                };
+            case "delete_email":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                await ms365Ops.deleteEmail(args?.messageId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✅ Email deleted permanently\n🆔 Message ID: ${args?.messageId}`
+                        }
+                    ]
+                };
+            case "get_attachment":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                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\n📄 Content available in base64 format`
+                        }
+                    ]
+                };
+            case "list_folders":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const folders = await ms365Ops.listFolders();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📁 Mail Folders\n\n${folders.map((folder) => `📂 ${folder.displayName}\n   🆔 ID: ${folder.id}\n   📧 Total Items: ${folder.totalItemCount}\n   📩 Unread: ${folder.unreadItemCount}\n`).join('\n')}`
+                        }
+                    ]
+                };
+            case "get_contacts":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const contacts = await ms365Ops.getContacts(args?.maxResults);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `👥 Contacts (${contacts.length} found)\n\n${contacts.map((contact) => `👤 ${contact.displayName}\n   📧 ${contact.emailAddresses?.[0]?.address || 'No email'}\n   📞 ${contact.businessPhones?.[0] || 'No phone'}\n`).join('\n')}`
+                        }
+                    ]
+                };
+            case "search_contacts":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const searchContactResults = await ms365Ops.searchContacts(args?.query, args?.maxResults);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔍 Contact Search Results (${searchContactResults.length} found)\n\n${searchContactResults.map((contact) => `👤 ${contact.displayName}\n   📧 ${contact.emailAddresses?.[0]?.address || 'No email'}\n   📞 ${contact.businessPhones?.[0] || 'No phone'}\n`).join('\n')}`
+                        }
+                    ]
+                };
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        logger.error(`Tool execution error for ${name}:`, error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Error executing ${name}: ${error instanceof Error ? error.message : String(error)}`
+                }
+            ],
+            isError: true
+        };
+    }
+});
+async function main() {
+    ms365Config = parseArgs();
+    if (ms365Config.setupAuth) {
+        try {
+            await enhancedMS365Auth.setupCredentials();
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('Setup failed:', error);
+            process.exit(1);
+        }
+    }
+    if (ms365Config.resetAuth) {
+        try {
+            await enhancedMS365Auth.resetAuth();
+            console.log('✅ Authentication data cleared successfully');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('Reset failed:', error);
+            process.exit(1);
+        }
+    }
+    if (ms365Config.login) {
+        try {
+            console.log('🔐 Starting Microsoft 365 authentication...\n');
+            await enhancedMS365Auth.authenticateWithDeviceCode();
+            console.log('✅ Login successful! You can now use MS365 MCP server.\n');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('❌ Login failed:', error);
+            process.exit(1);
+        }
+    }
+    if (ms365Config.logout) {
+        try {
+            await enhancedMS365Auth.resetAuth();
+            console.log('✅ Logged out successfully');
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('❌ Logout failed:', error);
+            process.exit(1);
+        }
+    }
+    if (ms365Config.verifyLogin) {
+        try {
+            const isAuthenticated = await enhancedMS365Auth.isAuthenticated();
+            const accounts = await enhancedMS365Auth.listAuthenticatedAccounts();
+            const storageInfo = enhancedMS365Auth.getStorageInfo();
+            console.log('\n📊 MS365 Authentication Status\n');
+            console.log(`Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}`);
+            console.log(`Storage method: ${storageInfo.method}`);
+            console.log(`Storage location: ${storageInfo.location}`);
+            console.log(`Authenticated accounts: ${accounts.length > 0 ? accounts.join(', ') : 'None'}\n`);
+            process.exit(isAuthenticated ? 0 : 1);
+        }
+        catch (error) {
+            console.error('❌ Verification failed:', error);
+            process.exit(1);
+        }
+    }
+    logger.log('Starting MS365 MCP Server...');
+    if (ms365Config.multiUser) {
+        logger.log('Multi-user mode enabled');
+    }
+    // Display storage information
+    const storageInfo = enhancedMS365Auth.getStorageInfo();
+    logger.log(`Credential storage: ${storageInfo.method} at ${storageInfo.location}`);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.log('MS365 MCP Server running on stdio');
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        logger.error('Failed to start MS365 MCP Server:', error);
+        process.exit(1);
+    });
+}