@masonator/m365-mcp 0.2.0 → 0.4.0

package/dist/__tests__/auth.test.js

@@ -2,7 +2,13 @@ import { jest } from '@jest/globals';
 import { mkdtempSync, rmSync, readFileSync, writeFileSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { getConfigDir, loadTokens, saveTokens, deleteTokens, isTokenExpired, loadAuthConfig, SCOPES, refreshAccessToken, getAccessToken, findAvailablePort, exchangeCodeForTokens, openBrowser, waitForAuthCallback, } from '../lib/auth.js';
+// Mock child_process to prevent browser tabs opening during tests
+const mockExecFile = jest.fn();
+jest.unstable_mockModule('node:child_process', () => ({
+    execFile: mockExecFile,
+}));
+// Dynamic import AFTER mock registration
+const { getConfigDir, loadTokens, saveTokens, deleteTokens, isTokenExpired, loadAuthConfig, SCOPES, refreshAccessToken, getAccessToken, findAvailablePort, exchangeCodeForTokens, openBrowser, waitForAuthCallback, } = await import('../lib/auth.js');
 const sampleTokens = {
     access_token: 'access-abc-123',
     refresh_token: 'refresh-xyz-789',
@@ -382,8 +388,23 @@ describe('findAvailablePort', () => {
     });
 });
 describe('openBrowser', () => {
-    it('does not throw for a URL string', () => {
-        // openBrowser calls execFile which may fail, but should not throw
+    afterEach(() => {
+        mockExecFile.mockClear();
+    });
+    it('calls execFile with the correct command for the platform', () => {
+        openBrowser('https://example.com');
+        // On macOS (darwin), should call 'open'
+        if (process.platform === 'darwin') {
+            expect(mockExecFile).toHaveBeenCalledWith('open', ['https://example.com']);
+        }
+        else {
+            expect(mockExecFile).toHaveBeenCalled();
+        }
+    });
+    it('does not throw when execFile throws', () => {
+        mockExecFile.mockImplementation(() => {
+            throw new Error('Command not found');
+        });
         expect(() => openBrowser('https://example.com')).not.toThrow();
     });
 });

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

@@ -31,13 +31,25 @@ describe('executeMail', () => {
         expect(result).toContain('Importance: high | Read: Yes');
         expect(result).toContain('Here are the meeting notes from today.');
     });
-    it('handles search param', async () => {
+    it('handles search param without $orderBy', async () => {
         mockGraphFetch.mockResolvedValue({
             ok: true,
             data: { value: [] },
         });
         await executeMail('test-token', { search: 'quarterly report' });
-        expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('$search="quarterly%20report"'), 'test-token', { timezone: false });
+        const calledPath = mockGraphFetch.mock.calls[0][0];
+        expect(calledPath).toContain('$search="quarterly%20report"');
+        expect(calledPath).not.toContain('$orderby');
+    });
+    it('includes $orderBy when no search is provided', async () => {
+        mockGraphFetch.mockResolvedValue({
+            ok: true,
+            data: { value: [] },
+        });
+        await executeMail('test-token', {});
+        const calledPath = mockGraphFetch.mock.calls[0][0];
+        expect(calledPath).toContain('$orderby=receivedDateTime desc');
+        expect(calledPath).not.toContain('$search');
     });
     it('handles empty results', async () => {
         mockGraphFetch.mockResolvedValue({

package/dist/__tests__/tools/server-info.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tools/server-info.test.js

@@ -0,0 +1,60 @@
+import { executeServerInfo } from '../../lib/tools/server-info.js';
+describe('executeServerInfo', () => {
+    it('returns server version and metadata', () => {
+        const result = executeServerInfo();
+        expect(result).toContain('# m365-mcp v');
+        expect(result).toContain(`Node: ${process.version}`);
+        expect(result).toContain(`Platform: ${process.platform} ${process.arch}`);
+    });
+    it('lists all available tools', () => {
+        const result = executeServerInfo();
+        expect(result).toContain('ms_auth_status');
+        expect(result).toContain('ms_profile');
+        expect(result).toContain('ms_calendar');
+        expect(result).toContain('ms_mail');
+        expect(result).toContain('ms_chat');
+        expect(result).toContain('ms_files');
+        expect(result).toContain('ms_transcripts');
+        expect(result).toContain('ms_server_info');
+        expect(result).toContain('Tools (8)');
+    });
+    it('shows environment variable status without exposing values', () => {
+        const result = executeServerInfo();
+        expect(result).toContain('MS365_MCP_CLIENT_ID:');
+        expect(result).toContain('MS365_MCP_TENANT_ID:');
+        // Should show 'set' or 'not set', never the actual value
+        expect(result).not.toMatch(/MS365_MCP_CLIENT_ID: [a-f0-9-]{10,}/);
+    });
+    it('reports env var as set when present', () => {
+        const original = process.env['MS365_MCP_TIMEZONE'];
+        try {
+            process.env['MS365_MCP_TIMEZONE'] = 'Europe/London';
+            const result = executeServerInfo();
+            expect(result).toContain('MS365_MCP_TIMEZONE: Europe/London');
+        }
+        finally {
+            if (original === undefined) {
+                delete process.env['MS365_MCP_TIMEZONE'];
+            }
+            else {
+                process.env['MS365_MCP_TIMEZONE'] = original;
+            }
+        }
+    });
+    it('reports default for MS365_MCP_REDIRECT_URL when not set', () => {
+        const original = process.env['MS365_MCP_REDIRECT_URL'];
+        try {
+            delete process.env['MS365_MCP_REDIRECT_URL'];
+            const result = executeServerInfo();
+            expect(result).toContain('MS365_MCP_REDIRECT_URL: default (dynamic port)');
+        }
+        finally {
+            if (original === undefined) {
+                delete process.env['MS365_MCP_REDIRECT_URL'];
+            }
+            else {
+                process.env['MS365_MCP_REDIRECT_URL'] = original;
+            }
+        }
+    });
+});

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

@@ -8,7 +8,7 @@ jest.unstable_mockModule('../../lib/graph.js', () => ({
 const mockFetch = jest.fn();
 globalThis.fetch = mockFetch;
 // Dynamic import AFTER mocks are registered
-const { executeTranscripts, extractMeetingId, parseTranscriptId } = await import('../../lib/tools/transcripts.js');
+const { executeTranscripts, extractMeetingId, parseTranscriptId, matchTranscriptsToEvent } = await import('../../lib/tools/transcripts.js');
 // ── Helpers ────────────────────────────────────────────────────────────────
 function makeJoinUrl(threadId, oid, tid = 'tenant-123') {
     const context = JSON.stringify({ Tid: tid, Oid: oid });
@@ -113,6 +113,73 @@ describe('parseTranscriptId', () => {
         });
     });
 });
+// ── matchTranscriptsToEvent ────────────────────────────────────────────────
+describe('matchTranscriptsToEvent', () => {
+    it('returns single transcript without filtering', () => {
+        const transcripts = [{ id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' }];
+        const event = { start: { dateTime: '2025-06-22T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toEqual([{ id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' }]);
+    });
+    it('returns closest transcript when multiple exist', () => {
+        const transcripts = [
+            { id: 'tx-week1', createdDateTime: '2025-06-15T10:02:00Z' },
+            { id: 'tx-week2', createdDateTime: '2025-06-22T10:03:00Z' },
+            { id: 'tx-week3', createdDateTime: '2025-06-29T10:01:00Z' },
+        ];
+        const event = { start: { dateTime: '2025-06-22T10:00:00Z' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toEqual([{ id: 'tx-week2', createdDateTime: '2025-06-22T10:03:00Z' }]);
+    });
+    it('returns all transcripts when event has no start time', () => {
+        const transcripts = [
+            { id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' },
+            { id: 'tx-2', createdDateTime: '2025-06-22T10:00:00Z' },
+        ];
+        const event = {};
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(2);
+    });
+    it('returns all transcripts when no createdDateTime available', () => {
+        const transcripts = [{ id: 'tx-1' }, { id: 'tx-2' }];
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(2);
+    });
+    it('returns empty array for zero transcripts', () => {
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent([], event);
+        expect(result).toHaveLength(0);
+    });
+    it('ignores transcripts with invalid createdDateTime', () => {
+        const transcripts = [
+            { id: 'tx-bad', createdDateTime: 'not-a-date' },
+            { id: 'tx-good', createdDateTime: '2025-06-15T10:05:00Z' },
+        ];
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toEqual([{ id: 'tx-good', createdDateTime: '2025-06-15T10:05:00Z' }]);
+    });
+    it('returns all when event start dateTime is invalid', () => {
+        const transcripts = [
+            { id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' },
+            { id: 'tx-2', createdDateTime: '2025-06-22T10:00:00Z' },
+        ];
+        const event = { start: { dateTime: 'not-a-date' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(2);
+    });
+    it('returns empty when closest transcript is beyond 24-hour threshold', () => {
+        const transcripts = [
+            { id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' },
+            { id: 'tx-2', createdDateTime: '2025-06-22T10:00:00Z' },
+        ];
+        // Event is 4 days away from nearest transcript
+        const event = { start: { dateTime: '2025-06-19T10:00:00Z' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(0);
+    });
+});
 // ── executeTranscripts ─────────────────────────────────────────────────────
 describe('executeTranscripts', () => {
     afterEach(() => {
@@ -121,11 +188,9 @@ describe('executeTranscripts', () => {
     });
     // ── Drill-down mode ──────────────────────────────────────────────────
     describe('drill-down mode', () => {
-        it('returns full transcript for valid compound ID', async () => {
+        it('returns short transcript marked as complete', async () => {
             const vttContent = 'WEBVTT\n\n00:00:00.000 --> 00:00:05.000\nHello world';
-            // VTT content fetch (raw fetch, v1.0 succeeds)
             mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
-            // Meeting subject fetch
             mockGraphFetch.mockResolvedValueOnce({
                 ok: true,
                 data: { subject: 'Team Standup' },
@@ -134,15 +199,77 @@ describe('executeTranscripts', () => {
                 transcript_id: 'meetingId123/transcriptId456',
             });
             expect(result).toContain('# Transcript: Team Standup');
+            expect(result).toContain('(complete)');
             expect(result).toContain(vttContent);
+            expect(result).not.toContain('To continue reading');
+        });
+        it('paginates long transcript with continuation instructions', async () => {
+            const vttContent = 'WEBVTT\n\n' + 'A'.repeat(15000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Long Meeting' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting123/transcript456',
+            });
+            expect(result).toContain('# Transcript: Long Meeting');
+            expect(result).toContain(`Length: ${vttContent.length} chars`);
+            expect(result).toContain('Showing: 0–10000');
+            expect(result).toContain(`Remaining: ${vttContent.length - 10000}`);
+            expect(result).toContain('To continue reading');
+            expect(result).toContain('offset=10000');
+            // Should not contain the full content
+            expect(result).not.toContain('A'.repeat(15000));
+        });
+        it('returns next chunk when offset is provided', async () => {
+            const vttContent = 'B'.repeat(5000) + 'C'.repeat(5000) + 'D'.repeat(5000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Offset Test' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+                offset: 10000,
+            });
+            expect(result).toContain('Showing: 10000–15000');
+            expect(result).toContain('Remaining: 0');
+            expect(result).not.toContain('To continue reading');
+            // Should contain only 'D' content
+            expect(result).toContain('D'.repeat(5000));
+        });
+        it('respects custom length parameter', async () => {
+            const vttContent = 'X'.repeat(30000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Custom Length' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+                length: 20000,
+            });
+            expect(result).toContain('Showing: 0–20000');
+            expect(result).toContain('Remaining: 10000');
+        });
+        it('clamps length to max 50000', async () => {
+            const vttContent = 'Y'.repeat(80000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Max Length' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+                length: 999999,
+            });
+            expect(result).toContain('Showing: 0–50000');
         });
         it('falls back to beta when v1.0 returns 403', async () => {
             const vttContent = 'WEBVTT\n\nFallback content';
-            // v1.0 returns 403
             mockFetch.mockResolvedValueOnce(mockResponse('Forbidden', 403));
-            // beta returns successfully
             mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
-            // Meeting subject
             mockGraphFetch.mockResolvedValueOnce({
                 ok: true,
                 data: { subject: 'Beta Meeting' },
@@ -225,46 +352,14 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'transcript-001' }] },
             });
-            // VTT content
-            const vttContent = 'WEBVTT\n\n00:00:00.000 --> 00:00:05.000\nHello from sprint';
-            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
             expect(result).toContain('Found 1 meetings, 1 with transcripts.');
             expect(result).toContain('## Sprint Planning');
             expect(result).toContain('Date: 2025-06-15T10:00:00');
             expect(result).toContain('Attendees: Alice, Bob');
             expect(result).toContain(`Transcript ID: ${meetingId}/transcript-001`);
-            expect(result).toContain(vttContent);
-        });
-        it('truncates VTT preview to ~3000 chars', async () => {
-            const threadId = '19:meeting_long@thread.v2';
-            const oid = 'oid-long';
-            const joinUrl = makeJoinUrl(threadId, oid);
-            // Calendar view
-            mockGraphFetch.mockResolvedValueOnce({
-                ok: true,
-                data: {
-                    value: [
-                        {
-                            subject: 'Long Meeting',
-                            start: { dateTime: '2025-06-15T10:00:00' },
-                            onlineMeeting: { joinUrl },
-                        },
-                    ],
-                },
-            });
-            // Transcripts list
-            mockGraphFetch.mockResolvedValueOnce({
-                ok: true,
-                data: { value: [{ id: 'tx-long' }] },
-            });
-            // Long VTT content
-            const longVtt = 'WEBVTT\n\n' + 'A'.repeat(4000);
-            mockFetch.mockResolvedValueOnce(mockResponse(longVtt));
-            const result = await executeTranscripts('test-token', { date: '2025-06-15' });
-            expect(result).toContain('... [truncated — use transcript_id for full content]');
-            // The preview should not contain the full 4000-char string
-            expect(result).not.toContain('A'.repeat(4000));
+            // List mode no longer fetches VTT previews — drill-down handles full content
+            expect(mockFetch).not.toHaveBeenCalled();
         });
         it('handles empty calendar (no meetings)', async () => {
             mockGraphFetch.mockResolvedValueOnce({
@@ -358,13 +453,12 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'tx-500' }] },
             });
-            // v1.0 VTT fetch returns 500 (non-retryable)
-            mockFetch.mockResolvedValueOnce(mockResponse('Internal Server Error', 500));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
-            // Meeting has transcripts but VTT download failed — still shows meeting without preview
+            // Meeting has transcripts — listed without VTT preview
             expect(result).toContain('1 with transcripts');
             expect(result).toContain('Server Error Meeting');
-            expect(mockFetch).toHaveBeenCalledTimes(1); // No beta retry for 500
+            // List mode no longer fetches VTT content
+            expect(mockFetch).not.toHaveBeenCalled();
         });
         it('skips meeting when both v1.0 and beta transcript listing fail with non-retryable error', async () => {
             const threadId = '19:meeting_fail@thread.v2';
@@ -423,8 +517,6 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'tx-beta' }] },
             });
-            // VTT content
-            mockFetch.mockResolvedValueOnce(mockResponse('WEBVTT\n\nBeta content'));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
             expect(result).toContain('1 with transcripts');
             expect(result).toContain('Beta Transcripts');
@@ -456,13 +548,110 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'tx-1' }] },
             });
-            // VTT content
-            mockFetch.mockResolvedValueOnce(mockResponse('WEBVTT\n\nOnline content'));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
             // Only 1 meeting (with joinUrl) counted, 1 with transcripts
             expect(result).toContain('Found 1 meetings, 1 with transcripts.');
             expect(result).toContain('Online Meeting');
             expect(result).not.toContain('In-Person Meeting');
         });
+        it('matches correct transcript to each occurrence of a recurring meeting', async () => {
+            const threadId = '19:recurring_standup@thread.v2';
+            const oid = 'organizer-oid';
+            const joinUrl = makeJoinUrl(threadId, oid);
+            const meetingId = Buffer.from(`1*${oid}*0**${threadId}`).toString('base64');
+            // Calendar view returns two occurrences with the SAME join URL
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        {
+                            subject: 'Weekly Standup',
+                            start: { dateTime: '2025-06-15T10:00:00' },
+                            end: { dateTime: '2025-06-15T10:30:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                        {
+                            subject: 'Weekly Standup',
+                            start: { dateTime: '2025-06-22T10:00:00' },
+                            end: { dateTime: '2025-06-22T10:30:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                    ],
+                },
+            });
+            // Transcript list fetched ONCE (cached for second occurrence)
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        { id: 'tx-week1', createdDateTime: '2025-06-15T10:02:00Z' },
+                        { id: 'tx-week2', createdDateTime: '2025-06-22T10:03:00Z' },
+                    ],
+                },
+            });
+            const result = await executeTranscripts('test-token', {
+                start: '2025-06-14T00:00:00Z',
+                end: '2025-06-23T00:00:00Z',
+            });
+            // Both occurrences found with transcripts
+            expect(result).toContain('2 with transcripts');
+            // Each occurrence has its own distinct transcript ID
+            expect(result).toContain(`${meetingId}/tx-week1`);
+            expect(result).toContain(`${meetingId}/tx-week2`);
+            // List mode no longer fetches VTT content
+            expect(mockFetch).not.toHaveBeenCalled();
+            // Transcript list fetched only once (not twice) — cached for recurring
+            const transcriptCalls = mockGraphFetch.mock.calls.filter((call) => call[0].includes('/transcripts'));
+            expect(transcriptCalls).toHaveLength(1);
+        });
+        it('skips recurring occurrence that has no matching transcript', async () => {
+            const threadId = '19:recurring_weekly@thread.v2';
+            const oid = 'oid-recurring';
+            const joinUrl = makeJoinUrl(threadId, oid);
+            const meetingId = Buffer.from(`1*${oid}*0**${threadId}`).toString('base64');
+            // Three occurrences, but only two have transcripts
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        {
+                            subject: 'Team Sync',
+                            start: { dateTime: '2025-06-08T14:00:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                        {
+                            subject: 'Team Sync',
+                            start: { dateTime: '2025-06-15T14:00:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                        {
+                            subject: 'Team Sync',
+                            start: { dateTime: '2025-06-22T14:00:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                    ],
+                },
+            });
+            // Only two transcripts exist (meeting on Jun 15 wasn't recorded)
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        { id: 'tx-jun8', createdDateTime: '2025-06-08T14:01:00Z' },
+                        { id: 'tx-jun22', createdDateTime: '2025-06-22T14:02:00Z' },
+                    ],
+                },
+            });
+            const result = await executeTranscripts('test-token', {
+                start: '2025-06-01T00:00:00Z',
+                end: '2025-06-30T00:00:00Z',
+            });
+            // 3 meetings found, but only 2 have matching transcripts
+            expect(result).toContain('Found 3 meetings, 2 with transcripts.');
+            expect(result).toContain(`${meetingId}/tx-jun8`);
+            expect(result).toContain(`${meetingId}/tx-jun22`);
+            // List mode no longer fetches VTT content
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
     });
 });

package/dist/index.js

@@ -10,6 +10,7 @@ import { mailToolDefinition, executeMail } from './lib/tools/mail.js';
 import { chatToolDefinition, executeChat } from './lib/tools/chat.js';
 import { filesToolDefinition, executeFiles } from './lib/tools/files.js';
 import { transcriptsToolDefinition, executeTranscripts } from './lib/tools/transcripts.js';
+import { serverInfoToolDefinition, executeServerInfo } from './lib/tools/server-info.js';
 // Validate env vars at startup
 try {
     loadAuthConfig();
@@ -23,7 +24,7 @@ catch (error) {
     process.stderr.write('  MS365_MCP_CLIENT_SECRET   - Azure AD client secret (confidential clients only)\n');
     process.exit(1);
 }
-const server = new Server({ name: 'm365-mcp', version: '0.2.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'm365-mcp', version: '0.4.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         authStatusToolDefinition,
@@ -33,17 +34,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         chatToolDefinition,
         filesToolDefinition,
         transcriptsToolDefinition,
+        serverInfoToolDefinition,
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args = {} } = request.params;
     try {
         const config = loadAuthConfig();
-        // auth_status handles its own auth
+        // Tools that don't require a valid token
         if (name === 'ms_auth_status') {
             const result = await executeAuthStatus(config);
             return { content: [{ type: 'text', text: result }] };
         }
+        if (name === 'ms_server_info') {
+            const result = executeServerInfo();
+            return { content: [{ type: 'text', text: result }] };
+        }
         // All other tools need a valid token
         const token = await getAccessToken(config);
         let result;

package/dist/lib/tools/mail.js

@@ -41,10 +41,14 @@ function formatMessage(msg) {
  */
 export async function executeMail(token, args) {
     const count = Math.min(Math.max(args.count ?? 10, 1), 25);
-    let path = `/me/messages?$top=${count}&$orderby=receivedDateTime desc` +
-        `&$select=subject,from,receivedDateTime,bodyPreview,isRead,importance`;
+    const select = 'subject,from,receivedDateTime,bodyPreview,isRead,importance';
+    let path;
     if (args.search) {
-        path += `&$search="${encodeURIComponent(args.search)}"`;
+        // $orderBy is not supported with $search — Graph returns results by relevance
+        path = `/me/messages?$top=${count}&$select=${select}&$search="${encodeURIComponent(args.search)}"`;
+    }
+    else {
+        path = `/me/messages?$top=${count}&$orderby=receivedDateTime desc&$select=${select}`;
     }
     const result = await graphFetch(path, token, { timezone: false });
     if (!result.ok) {

package/dist/lib/tools/server-info.d.ts

@@ -0,0 +1,9 @@
+export declare const serverInfoToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function executeServerInfo(): string;

package/dist/lib/tools/server-info.js

@@ -0,0 +1,53 @@
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const serverInfoToolDefinition = {
+    name: 'ms_server_info',
+    description: 'Returns m365-mcp server metadata: version, available tools, and runtime info. Useful for debugging.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+const TOOL_NAMES = [
+    'ms_auth_status',
+    'ms_profile',
+    'ms_calendar',
+    'ms_mail',
+    'ms_chat',
+    'ms_files',
+    'ms_transcripts',
+    'ms_server_info',
+];
+function getVersion() {
+    try {
+        const dir = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(dir, '..', '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function executeServerInfo() {
+    const version = getVersion();
+    const lines = [];
+    lines.push(`# m365-mcp v${version}`);
+    lines.push('');
+    lines.push(`Node: ${process.version}`);
+    lines.push(`Platform: ${process.platform} ${process.arch}`);
+    lines.push('');
+    lines.push(`## Tools (${TOOL_NAMES.length})`);
+    for (const name of TOOL_NAMES) {
+        lines.push(`- ${name}`);
+    }
+    lines.push('');
+    lines.push('## Environment');
+    lines.push(`MS365_MCP_CLIENT_ID: ${process.env['MS365_MCP_CLIENT_ID'] ? 'set' : 'not set'}`);
+    lines.push(`MS365_MCP_CLIENT_SECRET: ${process.env['MS365_MCP_CLIENT_SECRET'] ? 'set' : 'not set'}`);
+    lines.push(`MS365_MCP_TENANT_ID: ${process.env['MS365_MCP_TENANT_ID'] ? 'set' : 'not set'}`);
+    lines.push(`MS365_MCP_REDIRECT_URL: ${process.env['MS365_MCP_REDIRECT_URL'] || 'default (dynamic port)'}`);
+    lines.push(`MS365_MCP_TIMEZONE: ${process.env['MS365_MCP_TIMEZONE'] || 'auto'}`);
+    return lines.join('\n');
+}

package/dist/lib/tools/transcripts.d.ts

@@ -20,9 +20,43 @@ export declare const transcriptsToolDefinition: {
                 type: string;
                 description: string;
             };
+            offset: {
+                type: string;
+                description: string;
+            };
+            length: {
+                type: string;
+                description: string;
+            };
         };
     };
 };
+interface CalendarEvent {
+    subject?: string;
+    start?: {
+        dateTime?: string;
+    };
+    end?: {
+        dateTime?: string;
+    };
+    attendees?: Array<{
+        emailAddress?: {
+            name?: string;
+        };
+    }>;
+    organizer?: {
+        emailAddress?: {
+            name?: string;
+        };
+    };
+    onlineMeeting?: {
+        joinUrl?: string;
+    } | null;
+}
+interface TranscriptEntry {
+    id: string;
+    createdDateTime?: string;
+}
 /**
  * Extracts a Graph online meeting ID from a Teams join URL.
  *
@@ -39,13 +73,25 @@ export declare function parseTranscriptId(transcriptId: string): {
     meetingId: string;
     transcriptId: string;
 } | null;
+/**
+ * Matches transcripts to a specific calendar event occurrence.
+ * For recurring meetings (multiple transcripts sharing the same meeting ID),
+ * finds the transcript whose createdDateTime is closest to the event's start time.
+ *
+ * When there's only one transcript, returns it without filtering.
+ * When no createdDateTime data is available, falls back to returning all transcripts.
+ */
+export declare function matchTranscriptsToEvent(transcripts: TranscriptEntry[], event: CalendarEvent): TranscriptEntry[];
 /**
  * Fetches meeting transcripts from Microsoft Teams.
- * Supports two modes: list (date range) and drill-down (specific transcript).
+ * Supports two modes: list (date range) and drill-down (specific transcript with pagination).
  */
 export declare function executeTranscripts(token: string, args: {
     date?: string;
     start?: string;
     end?: string;
     transcript_id?: string;
+    offset?: number;
+    length?: number;
 }): Promise<string>;
+export {};

package/dist/lib/tools/transcripts.js

@@ -1,7 +1,12 @@
 import { graphFetch } from '../graph.js';
+const DEFAULT_CHUNK_SIZE = 10000;
+const MAX_CHUNK_SIZE = 50000;
 export const transcriptsToolDefinition = {
     name: 'ms_transcripts',
-    description: 'Fetch meeting transcripts from Microsoft Teams. Returns preview (~3000 chars) + transcript_id for drill-down. Use transcript_id to get the full transcript.',
+    description: 'Fetch meeting transcripts from Microsoft Teams. ' +
+        'Without transcript_id: lists meetings with ~3000 char previews. ' +
+        'With transcript_id: returns transcript content in chunks (default 10,000 chars). ' +
+        'Use offset to paginate through long transcripts.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -10,7 +15,15 @@ export const transcriptsToolDefinition = {
             end: { type: 'string', description: 'End of date range (ISO 8601)' },
             transcript_id: {
                 type: 'string',
-                description: 'Transcript ID for full content drill-down (from a previous list call)',
+                description: 'Transcript ID for content drill-down (from a previous list call)',
+            },
+            offset: {
+                type: 'integer',
+                description: 'Character offset for pagination (default 0). Use the value from the previous response to continue reading.',
+            },
+            length: {
+                type: 'integer',
+                description: 'Max characters to return (default 10000, max 50000)',
             },
         },
     },
@@ -79,6 +92,55 @@ function todayRange() {
     const day = String(now.getDate()).padStart(2, '0');
     return dateRangeForDay(`${year}-${month}-${day}`);
 }
+/**
+ * Matches transcripts to a specific calendar event occurrence.
+ * For recurring meetings (multiple transcripts sharing the same meeting ID),
+ * finds the transcript whose createdDateTime is closest to the event's start time.
+ *
+ * When there's only one transcript, returns it without filtering.
+ * When no createdDateTime data is available, falls back to returning all transcripts.
+ */
+export function matchTranscriptsToEvent(transcripts, event) {
+    if (transcripts.length <= 1) {
+        return transcripts;
+    }
+    const eventStartStr = event.start?.dateTime;
+    if (!eventStartStr) {
+        return transcripts;
+    }
+    const eventStartMs = new Date(eventStartStr).getTime();
+    if (isNaN(eventStartMs)) {
+        return transcripts;
+    }
+    // Find transcript with createdDateTime closest to event start
+    let closest = null;
+    let closestDiff = Infinity;
+    for (const t of transcripts) {
+        if (!t.createdDateTime)
+            continue;
+        const createdMs = new Date(t.createdDateTime).getTime();
+        if (isNaN(createdMs))
+            continue;
+        const diff = Math.abs(createdMs - eventStartMs);
+        if (diff < closestDiff) {
+            closest = t;
+            closestDiff = diff;
+        }
+    }
+    // Only match if within 24 hours — handles timezone discrepancies between
+    // event times (user's preferred timezone) and transcript UTC timestamps,
+    // while still distinguishing daily recurring meeting occurrences.
+    const MAX_DIFF_MS = 24 * 60 * 60 * 1000;
+    if (closest && closestDiff <= MAX_DIFF_MS) {
+        return [closest];
+    }
+    if (!closest) {
+        // No transcripts have valid createdDateTime — fall back to returning all
+        return transcripts;
+    }
+    // Closest transcript is too far from this event — no match for this occurrence
+    return [];
+}
 /**
  * Fetches VTT transcript content using raw fetch (not graphFetch, since it returns text).
  * Tries v1.0 first, falls back to beta on 403/400.
@@ -120,9 +182,9 @@ async function fetchTranscriptsList(token, meetingId) {
     return null;
 }
 /**
- * Handles drill-down mode: fetch full transcript by compound ID.
+ * Handles drill-down mode: fetch transcript by compound ID with pagination.
  */
-async function executeDrillDown(token, compoundId) {
+async function executeDrillDown(token, compoundId, offset, length) {
     const parsed = parseTranscriptId(compoundId);
     if (!parsed) {
         return 'Error: Invalid transcript_id format. Expected "{meetingId}/{transcriptId}".';
@@ -138,7 +200,25 @@ async function executeDrillDown(token, compoundId) {
     if (meetingResult.ok && meetingResult.data.subject) {
         subject = meetingResult.data.subject;
     }
-    return `# Transcript: ${subject}\n\n${vtt}`;
+    const totalLength = vtt.length;
+    // Short transcript — return it all, no pagination needed
+    if (totalLength <= length) {
+        return `# Transcript: ${subject}\nLength: ${totalLength} chars (complete)\n\n${vtt}`;
+    }
+    // Paginated: slice the requested chunk
+    const chunk = vtt.slice(offset, offset + length);
+    const end = offset + chunk.length;
+    const remaining = totalLength - end;
+    const lines = [];
+    lines.push(`# Transcript: ${subject}`);
+    lines.push(`Length: ${totalLength} chars | Showing: ${offset}–${end} | Remaining: ${remaining}`);
+    lines.push('');
+    lines.push(chunk);
+    if (remaining > 0) {
+        lines.push('');
+        lines.push(`--- To continue reading, call again with transcript_id="${compoundId}" offset=${end} ---`);
+    }
+    return lines.join('\n');
 }
 /**
  * Handles list mode: find meetings with transcripts in date range.
@@ -178,33 +258,45 @@ async function executeList(token, args) {
     if (meetingEvents.length === 0) {
         return 'No Teams meetings found in the given date range.';
     }
+    // Extract unique meeting IDs and map events to them
+    const meetingIdMap = new Map(); // joinUrl -> meetingId
+    const uniqueMeetingIds = new Set();
+    for (const event of meetingEvents) {
+        const joinUrl = event.onlineMeeting?.joinUrl;
+        if (!joinUrl || meetingIdMap.has(joinUrl))
+            continue;
+        const meetingId = extractMeetingId(joinUrl);
+        if (!meetingId)
+            continue;
+        meetingIdMap.set(joinUrl, meetingId);
+        uniqueMeetingIds.add(meetingId);
+    }
+    // Fetch all transcript lists in parallel (one per unique meeting ID)
+    const transcriptCache = new Map();
+    const fetchPromises = [...uniqueMeetingIds].map(async (meetingId) => {
+        const data = await fetchTranscriptsList(token, meetingId);
+        transcriptCache.set(meetingId, data?.value ?? []);
+    });
+    await Promise.all(fetchPromises);
     const sections = [];
     let transcriptCount = 0;
     for (const event of meetingEvents) {
         const joinUrl = event.onlineMeeting?.joinUrl;
         if (!joinUrl)
             continue;
-        const meetingId = extractMeetingId(joinUrl);
+        const meetingId = meetingIdMap.get(joinUrl);
         if (!meetingId)
             continue;
-        // Check for transcripts
-        const transcriptsData = await fetchTranscriptsList(token, meetingId);
-        if (!transcriptsData || transcriptsData.value.length === 0)
+        const allTranscripts = transcriptCache.get(meetingId);
+        if (!allTranscripts || allTranscripts.length === 0)
+            continue;
+        // Match transcripts to this specific event occurrence (handles recurring meetings)
+        const eventTranscripts = matchTranscriptsToEvent(allTranscripts, event);
+        if (eventTranscripts.length === 0)
             continue;
         transcriptCount++;
-        const firstTranscript = transcriptsData.value[0];
+        const firstTranscript = eventTranscripts[0];
         const compoundId = `${meetingId}/${firstTranscript.id}`;
-        // Download VTT preview
-        let vttPreview = '';
-        const vtt = await fetchVttContent(token, meetingId, firstTranscript.id);
-        if (vtt) {
-            if (vtt.length > 3000) {
-                vttPreview = vtt.slice(0, 3000) + '\n... [truncated — use transcript_id for full content]';
-            }
-            else {
-                vttPreview = vtt;
-            }
-        }
         const lines = [];
         lines.push(`## ${event.subject || 'Untitled'}`);
         lines.push(`Date: ${event.start?.dateTime || 'N/A'}`);
@@ -216,10 +308,6 @@ async function executeList(token, args) {
             lines.push(`Attendees: ${attendeeNames}`);
         }
         lines.push(`Transcript ID: ${compoundId}`);
-        if (vttPreview) {
-            lines.push('');
-            lines.push(vttPreview);
-        }
         sections.push(lines.join('\n'));
     }
     if (transcriptCount === 0) {
@@ -234,11 +322,13 @@ async function executeList(token, args) {
 }
 /**
  * Fetches meeting transcripts from Microsoft Teams.
- * Supports two modes: list (date range) and drill-down (specific transcript).
+ * Supports two modes: list (date range) and drill-down (specific transcript with pagination).
  */
 export async function executeTranscripts(token, args) {
     if (args.transcript_id) {
-        return executeDrillDown(token, args.transcript_id);
+        const offset = Math.max(args.offset ?? 0, 0);
+        const length = Math.min(Math.max(args.length ?? DEFAULT_CHUNK_SIZE, 1), MAX_CHUNK_SIZE);
+        return executeDrillDown(token, args.transcript_id, offset, length);
     }
     return executeList(token, args);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonator/m365-mcp",
   "scope": "@masonator",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "MCP server implementation for Microsoft 365 via Microsoft Graph API",
   "type": "module",
   "main": "./dist/index.js",