@masonator/m365-mcp 0.6.0 → 0.7.0

package/dist/__tests__/graph.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { graphFetch } from '../lib/graph.js';
+import { graphFetch, graphPost } from '../lib/graph.js';
 // Save original fetch
 const originalFetch = globalThis.fetch;
 afterEach(() => {
@@ -159,4 +159,94 @@ describe('graphFetch', () => {
             },
         });
     });
+    it('merges custom headers into request', async () => {
+        const mock = mockFetch({
+            ok: true,
+            json: () => Promise.resolve({ value: [] }),
+        });
+        await graphFetch('/me/messages', 'test-token', {
+            timezone: false,
+            headers: { ConsistencyLevel: 'eventual' },
+        });
+        const callHeaders = mock.mock.calls[0][1].headers;
+        expect(callHeaders).toHaveProperty('ConsistencyLevel', 'eventual');
+        expect(callHeaders).toHaveProperty('Authorization', 'Bearer test-token');
+    });
+    it('returns error when success response has invalid JSON', async () => {
+        mockFetch({
+            ok: true,
+            status: 200,
+            json: () => Promise.reject(new SyntaxError('Unexpected end of JSON input')),
+        });
+        const result = await graphFetch('/me', 'test-token');
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.status).toBe(200);
+            expect(result.error.message).toContain('not valid JSON');
+        }
+    });
+    it('handles response.text() failure on error path', async () => {
+        mockFetch({
+            ok: false,
+            status: 500,
+            text: () => Promise.reject(new Error('stream error')),
+        });
+        const result = await graphFetch('/me', 'test-token');
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error.status).toBe(500);
+            expect(result.error.message).toContain('unable to read error response body');
+        }
+    });
+});
+describe('graphPost', () => {
+    it('sends POST request with JSON body', async () => {
+        const mock = mockFetch({
+            ok: true,
+            json: () => Promise.resolve({ value: [{ scheduleId: 'user@example.com' }] }),
+        });
+        const result = await graphPost('/me/calendar/getSchedule', 'test-token', { schedules: ['user@example.com'] });
+        expect(result).toEqual({
+            ok: true,
+            data: { value: [{ scheduleId: 'user@example.com' }] },
+        });
+        expect(mock).toHaveBeenCalledWith('https://graph.microsoft.com/v1.0/me/calendar/getSchedule', expect.objectContaining({
+            method: 'POST',
+            body: JSON.stringify({ schedules: ['user@example.com'] }),
+            headers: expect.objectContaining({
+                Authorization: 'Bearer test-token',
+                'Content-Type': 'application/json',
+            }),
+        }));
+    });
+    it('returns error on failed POST', async () => {
+        mockFetch({ ok: false, status: 403 });
+        const result = await graphPost('/me/calendar/getSchedule', 'test-token', {});
+        expect(result).toEqual({
+            ok: false,
+            error: {
+                status: 403,
+                message: 'Insufficient permissions. Check granted scopes with ms_auth_status.',
+            },
+        });
+    });
+    it('handles network error on POST', async () => {
+        globalThis.fetch = jest.fn().mockRejectedValue(new Error('Network failure'));
+        const result = await graphPost('/me/calendar/getSchedule', 'test-token', {});
+        expect(result).toEqual({
+            ok: false,
+            error: { status: 0, message: 'Network error: Network failure' },
+        });
+    });
+    it('uses beta URL when beta option is true', async () => {
+        const mock = mockFetch({ ok: true, json: () => Promise.resolve({}) });
+        await graphPost('/me/calendar/getSchedule', 'test-token', {}, { beta: true });
+        expect(mock).toHaveBeenCalledWith('https://graph.microsoft.com/beta/me/calendar/getSchedule', expect.any(Object));
+    });
+    it('merges custom headers into POST request', async () => {
+        const mock = mockFetch({ ok: true, json: () => Promise.resolve({}) });
+        await graphPost('/test', 'test-token', {}, { timezone: false, headers: { 'X-Custom': 'value' } });
+        const callHeaders = mock.mock.calls[0][1].headers;
+        expect(callHeaders).toHaveProperty('X-Custom', 'value');
+    });
 });

package/dist/__tests__/tools/calendar.test.js

@@ -106,6 +106,24 @@ describe('executeCalendar', () => {
         await executeCalendar('test-token', {});
         expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining(`startDateTime=${todayStr}`), 'test-token', { timezone: true });
     });
+    it('includes Event ID when event has id field', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        id: 'event-abc123',
+                        subject: 'ID Test',
+                        isAllDay: false,
+                        start: { dateTime: '2025-01-15T09:00:00' },
+                        end: { dateTime: '2025-01-15T10:00:00' },
+                    },
+                ],
+            },
+        });
+        const result = await executeCalendar('test-token', { date: '2025-01-15' });
+        expect(result).toContain('Event ID: event-abc123');
+    });
     it('handles events with minimal fields', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,
@@ -194,6 +212,35 @@ describe('executeCalendar', () => {
         expect(result).not.toContain('A'.repeat(800));
         expect(result).toContain('A'.repeat(500) + '...');
     });
+    it('strips Teams meeting boilerplate from event body', async () => {
+        const teamsBody = 'Sprint planning session\n\n' +
+            '________________________________________________________________________________\n' +
+            'Microsoft Teams meeting\n' +
+            'Join on your computer, mobile app or room device\n' +
+            'Click here to join the meeting\n' +
+            'Meeting ID: 123 456 789\n' +
+            'Passcode: abc123\n' +
+            'Dial in: +1 555-0100';
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        subject: 'Teams Meeting',
+                        isAllDay: false,
+                        start: { dateTime: '2025-01-15T09:00:00' },
+                        end: { dateTime: '2025-01-15T10:00:00' },
+                        body: { contentType: 'text', content: teamsBody },
+                    },
+                ],
+            },
+        });
+        const result = await executeCalendar('test-token', { date: '2025-01-15' });
+        expect(result).toContain('Sprint planning session');
+        expect(result).not.toContain('Microsoft Teams meeting');
+        expect(result).not.toContain('Passcode');
+        expect(result).not.toContain('Dial in');
+    });
     it('requests body field in $select', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,
@@ -204,4 +251,119 @@ describe('executeCalendar', () => {
         expect(calledPath).toContain('body');
         expect(calledPath).not.toContain('bodyPreview');
     });
+    describe('calendars list mode', () => {
+        it('lists calendars with default marker', async () => {
+            mockGraphFetch.mockResolvedValue({
+                ok: true,
+                data: {
+                    value: [
+                        { name: 'Calendar', color: 'auto', isDefaultCalendar: true, canEdit: true },
+                        { name: 'Work', color: 'lightBlue', isDefaultCalendar: false, canEdit: false },
+                    ],
+                },
+            });
+            const result = await executeCalendar('test-token', { calendars: true });
+            expect(result).toContain('## Calendar (default)');
+            expect(result).toContain('Color: auto');
+            expect(result).toContain('Can edit: Yes');
+            expect(result).toContain('## Work');
+            expect(result).toContain('Can edit: No');
+            expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('/me/calendars'), 'test-token');
+        });
+        it('returns message when no calendars found', async () => {
+            mockGraphFetch.mockResolvedValue({
+                ok: true,
+                data: { value: [] },
+            });
+            const result = await executeCalendar('test-token', { calendars: true });
+            expect(result).toBe('No calendars found.');
+        });
+        it('handles error when listing calendars', async () => {
+            mockGraphFetch.mockResolvedValue({
+                ok: false,
+                error: { status: 403, message: 'Insufficient permissions.' },
+            });
+            const result = await executeCalendar('test-token', { calendars: true });
+            expect(result).toBe('Error: Insufficient permissions.');
+        });
+    });
+    describe('event detail mode', () => {
+        it('shows full event detail with attendees and Teams URL', async () => {
+            mockGraphFetch.mockResolvedValue({
+                ok: true,
+                data: {
+                    subject: 'Sprint Planning',
+                    start: { dateTime: '2025-01-15T09:00:00', timeZone: 'Europe/London' },
+                    end: { dateTime: '2025-01-15T10:00:00', timeZone: 'Europe/London' },
+                    organizer: { emailAddress: { name: 'Alice', address: 'alice@example.com' } },
+                    attendees: [
+                        {
+                            emailAddress: { name: 'Bob', address: 'bob@example.com' },
+                            status: { response: 'accepted' },
+                        },
+                        {
+                            emailAddress: { name: 'Carol', address: 'carol@example.com' },
+                            status: { response: 'tentative' },
+                        },
+                    ],
+                    body: {
+                        contentType: 'html',
+                        content: '<html><body><p>Sprint planning session</p><p>Please prepare your updates</p></body></html>',
+                    },
+                    location: { displayName: 'Conference Room B' },
+                    onlineMeeting: { joinUrl: 'https://teams.microsoft.com/l/meetup-join/abc123' },
+                    hasAttachments: true,
+                    showAs: 'busy',
+                    importance: 'high',
+                    categories: ['Work', 'Sprint'],
+                },
+            });
+            const result = await executeCalendar('test-token', { event_id: 'event-123' });
+            expect(result).toContain('## Sprint Planning');
+            expect(result).toContain('Time: 2025-01-15T09:00:00 - 2025-01-15T10:00:00');
+            expect(result).toContain('Location: Conference Room B');
+            expect(result).toContain('Organizer: Alice (alice@example.com)');
+            expect(result).toContain('Bob (accepted)');
+            expect(result).toContain('Carol (tentative)');
+            expect(result).toContain('Sprint planning session');
+            expect(result).toContain('Please prepare your updates');
+            expect(result).not.toContain('<p>');
+            expect(result).toContain('https://teams.microsoft.com/l/meetup-join/abc123');
+            expect(result).toContain('Categories: Work, Sprint');
+            expect(result).toContain('Importance: high');
+            expect(result).toContain('Show as: busy');
+            expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('/me/events/event-123'), 'test-token');
+        });
+        it('handles event with no online meeting', async () => {
+            mockGraphFetch.mockResolvedValue({
+                ok: true,
+                data: {
+                    subject: 'In-Person Meeting',
+                    start: { dateTime: '2025-01-15T14:00:00', timeZone: 'Europe/London' },
+                    end: { dateTime: '2025-01-15T15:00:00', timeZone: 'Europe/London' },
+                    organizer: { emailAddress: { name: 'Dave', address: 'dave@example.com' } },
+                    attendees: [],
+                    body: { contentType: 'text', content: 'Office meeting' },
+                    location: { displayName: 'Room C' },
+                    onlineMeeting: null,
+                },
+            });
+            const result = await executeCalendar('test-token', { event_id: 'event-456' });
+            expect(result).toContain('## In-Person Meeting');
+            expect(result).toContain('Location: Room C');
+            expect(result).not.toContain('Teams');
+            expect(result).not.toContain('joinUrl');
+        });
+        it('handles event_id error', async () => {
+            mockGraphFetch.mockResolvedValue({
+                ok: false,
+                error: {
+                    status: 404,
+                    message: 'Event not found.',
+                },
+            });
+            const result = await executeCalendar('test-token', { event_id: 'bad-id' });
+            expect(result).toBe('Error: Event not found.');
+        });
+    });
 });

package/dist/__tests__/tools/chat.test.js

@@ -124,7 +124,7 @@ describe('executeChat', () => {
         await executeChat('test-token', { chat_id: '19:abc@thread.v2' });
         expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('/me/chats/19%3Aabc%40thread.v2/messages'), 'test-token', { timezone: false });
     });
-    it('handles chat listing with no topic', async () => {
+    it('handles chat listing with no topic and no members', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,
             data: {
@@ -143,6 +143,88 @@ describe('executeChat', () => {
         expect(result).toContain('Type: oneOnOne');
         expect(result).toContain('Chat ID: chat-456');
     });
+    it('shows member names for oneOnOne chats without topic', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        id: 'chat-789',
+                        topic: null,
+                        chatType: 'oneOnOne',
+                        members: [{ displayName: 'Alice' }, { displayName: 'Bob' }],
+                        lastMessagePreview: {
+                            body: { content: 'Hi there' },
+                            createdDateTime: '2025-06-15T10:00:00Z',
+                        },
+                    },
+                ],
+            },
+        });
+        const result = await executeChat('test-token', {});
+        expect(result).toContain('## Alice, Bob');
+        expect(result).toContain('Type: oneOnOne');
+        expect(result).not.toContain('oneOnOne chat');
+    });
+    it('handles messages with missing from and createdDateTime', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        from: undefined,
+                        createdDateTime: undefined,
+                        body: { content: 'System message', contentType: 'text' },
+                    },
+                ],
+            },
+        });
+        const result = await executeChat('test-token', { chat_id: 'chat-123' });
+        expect(result).toContain('**Unknown**');
+        expect(result).toContain('(N/A)');
+        expect(result).toContain('System message');
+    });
+    it('falls back to oneOnOne chat when all member displayNames are undefined', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        id: 'chat-nonames',
+                        topic: null,
+                        chatType: 'oneOnOne',
+                        members: [{ displayName: undefined }, { displayName: undefined }],
+                        lastMessagePreview: null,
+                    },
+                ],
+            },
+        });
+        const result = await executeChat('test-token', {});
+        expect(result).toContain('## oneOnOne chat');
+    });
+    it('handles lastMessagePreview with null body content and null createdDateTime', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        id: 'chat-preview',
+                        topic: 'Preview Test',
+                        chatType: 'group',
+                        lastMessagePreview: {
+                            body: { content: null },
+                            createdDateTime: null,
+                        },
+                    },
+                ],
+            },
+        });
+        const result = await executeChat('test-token', {});
+        expect(result).toContain('## Preview Test');
+        expect(result).toContain('(no preview)');
+        // No timestamp in the last message line since createdDateTime is null
+        expect(result).toContain('Last message: (no preview)');
+    });
     it('handles messages with empty body', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,
@@ -181,6 +263,71 @@ describe('executeChat', () => {
         expect(result).not.toContain('<p>');
         expect(result).not.toContain('<at');
     });
+    it('lists chat members when chat_id and members are provided', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        displayName: 'Alice Smith',
+                        email: 'alice@example.com',
+                        roles: ['owner'],
+                    },
+                    {
+                        displayName: 'Bob Jones',
+                        email: 'bob@example.com',
+                        roles: ['guest'],
+                    },
+                ],
+            },
+        });
+        const result = await executeChat('test-token', { chat_id: 'chat-123', members: true });
+        expect(result).toContain('## Chat Members');
+        expect(result).toContain('Alice Smith');
+        expect(result).toContain('alice@example.com');
+        expect(result).toContain('owner');
+        expect(result).toContain('Bob Jones');
+        expect(result).toContain('bob@example.com');
+        expect(result).toContain('guest');
+    });
+    it('does not include $select in members URL', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: { value: [] },
+        });
+        await executeChat('test-token', { chat_id: 'chat-123', members: true });
+        const calledPath = mockGraphFetch.mock.calls[0][0];
+        expect(calledPath).toContain('/me/chats/chat-123/members');
+        expect(calledPath).not.toContain('$select');
+    });
+    it('handles empty members list', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: { value: [] },
+        });
+        const result = await executeChat('test-token', { chat_id: 'chat-123', members: true });
+        expect(result).toBe('No members found in this chat.');
+    });
+    it('handles error fetching members', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: false,
+            error: {
+                status: 403,
+                message: 'Insufficient permissions. Check granted scopes with ms_auth_status.',
+            },
+        });
+        const result = await executeChat('test-token', { chat_id: 'chat-123', members: true });
+        expect(result).toBe('Error: Insufficient permissions. Check granted scopes with ms_auth_status.');
+    });
+    it('does not include $orderby in chat list URL', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: { value: [] },
+        });
+        await executeChat('test-token', {});
+        const calledPath = mockGraphFetch.mock.calls[0][0];
+        expect(calledPath).not.toContain('$orderby');
+    });
     it('handles emoji tags in messages', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,

package/dist/__tests__/tools/files.test.js

@@ -39,6 +39,32 @@ describe('executeFiles', () => {
         expect(result).toContain('https://onedrive.example.com/Documents');
         expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('/me/drive/root/children'), 'test-token', { timezone: false });
     });
+    it('includes item ID when file items have id field', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        id: 'file-id-001',
+                        name: 'notes.txt',
+                        size: 1024,
+                        lastModifiedDateTime: '2025-06-15T10:00:00Z',
+                        file: { mimeType: 'text/plain' },
+                    },
+                ],
+            },
+        });
+        const result = await executeFiles('test-token', {});
+        expect(result).toContain('ID: file-id-001');
+    });
+    it('handles shared files error', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: false,
+            error: { status: 403, message: 'Access denied.' },
+        });
+        const result = await executeFiles('test-token', { shared: true });
+        expect(result).toBe('Error: Access denied.');
+    });
     it('handles path param', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,
@@ -117,6 +143,94 @@ describe('executeFiles', () => {
         await executeFiles('test-token', { search: 'test', path: '/Documents' });
         expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('/me/drive/root/search'), 'test-token', { timezone: false });
     });
+    it('fetches file detail with download URL', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                name: 'report.docx',
+                size: 25600,
+                lastModifiedDateTime: '2026-01-15T10:00:00Z',
+                webUrl: 'https://onedrive.example.com/report.docx',
+                '@microsoft.graph.downloadUrl': 'https://download.example.com/report.docx?token=abc',
+                file: {
+                    mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                },
+            },
+        });
+        const result = await executeFiles('test-token', { item_id: 'item-123' });
+        expect(result).toContain('# report.docx');
+        expect(result).toContain('Type: file');
+        expect(result).toContain('25.0 KB');
+        expect(result).toContain('Download URL: https://download.example.com/report.docx?token=abc');
+        expect(result).toContain('Web URL: https://onedrive.example.com/report.docx');
+        expect(mockGraphFetch).toHaveBeenCalledWith('/me/drive/items/item-123', 'test-token', {
+            timezone: false,
+        });
+    });
+    it('fetches file detail for folder without download URL', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                name: 'Documents',
+                size: 0,
+                lastModifiedDateTime: '2026-01-15T10:00:00Z',
+                webUrl: 'https://onedrive.example.com/Documents',
+                folder: { childCount: 12 },
+            },
+        });
+        const result = await executeFiles('test-token', { item_id: 'folder-456' });
+        expect(result).toContain('# Documents');
+        expect(result).toContain('Type: folder');
+        expect(result).toContain('Children: 12');
+        expect(result).not.toContain('Download URL');
+        expect(mockGraphFetch).toHaveBeenCalledWith('/me/drive/items/folder-456', 'test-token', {
+            timezone: false,
+        });
+    });
+    it('fetches shared files with sharer name', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: {
+                value: [
+                    {
+                        name: 'shared-doc.pdf',
+                        size: 51200,
+                        lastModifiedDateTime: '2026-01-20T14:00:00Z',
+                        webUrl: 'https://onedrive.example.com/shared-doc.pdf',
+                        file: { mimeType: 'application/pdf' },
+                        remoteItem: {
+                            shared: {
+                                sharedBy: { user: { displayName: 'Jane Smith' } },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        const result = await executeFiles('test-token', { shared: true });
+        expect(result).toContain('shared-doc.pdf');
+        expect(result).toContain('Shared by: Jane Smith');
+        expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('/me/drive/sharedWithMe'), 'test-token', { timezone: false });
+    });
+    it('handles empty shared files', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: { value: [] },
+        });
+        const result = await executeFiles('test-token', { shared: true });
+        expect(result).toBe('No shared files found.');
+    });
+    it('handles file detail error', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: false,
+            error: {
+                status: 404,
+                message: 'Resource not found. The item may not exist or you may lack access.',
+            },
+        });
+        const result = await executeFiles('test-token', { item_id: 'nonexistent' });
+        expect(result).toBe('Error: Resource not found. The item may not exist or you may lack access.');
+    });
 });
 describe('formatFileSize', () => {
     it('formats bytes', () => {