msteams-mcp 0.15.0 → 0.16.0

package/README.md

@@ -121,13 +121,14 @@ The server uses your system's Chrome (macOS/Linux) or Edge (Windows) for authent
 
 **Quick reactions:** `like`, `heart`, `laugh`, `surprised`, `sad`, `angry` can be used directly without searching.
 
-### Calendar
+### Calendar & Meetings
 
 | Tool | Description |
 |------|-------------|
 | `teams_get_meetings` | Get meetings from calendar (defaults to next 7 days) |
+| `teams_get_transcript` | Get meeting transcript (requires `threadId` from `teams_get_meetings`) |
 
-Returns: subject, times, organiser, join URL, `threadId` for meeting chat. Use with `teams_get_thread` to read meeting discussions.
+`teams_get_meetings` returns: subject, times, organiser, join URL, `threadId` for meeting chat. Use `threadId` with `teams_get_thread` to read meeting chat, or with `teams_get_transcript` to get the full transcript with speakers and timestamps.
 
 ### Session
 

package/dist/api/chatsvc-api.js

@@ -618,35 +618,38 @@ function parseContentWithMentionsAndLinks(content) {
     if (matches.length === 0) {
         return { html: markdownToTeamsHtml(content), mentions: [] };
     }
-    // Build result with mentions/links as inline elements
-    // Text segments between mentions/links get markdown conversion
+    // Strategy: replace mentions/links with unique placeholders, run the whole
+    // content through markdownToTeamsHtml (so links stay inline within their
+    // paragraph), then substitute placeholders back with actual HTML.
     const mentions = [];
-    let result = '';
-    let lastIndex = 0;
+    const placeholders = new Map();
     let mentionId = 0;
-    for (const m of matches) {
-        // Add markdown-converted text before this match
-        const textBefore = content.substring(lastIndex, m.index);
-        if (textBefore) {
-            result += markdownToTeamsHtml(textBefore);
-        }
+    // Build content with placeholders (process in reverse to preserve indices)
+    let placeholderContent = content;
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const m = matches[i];
+        const placeholder = `\uE000MCP_PH_${i}\uE001`;
+        let html;
         if (m.type === 'mention') {
             mentions.push({ mri: m.target, displayName: m.text });
-            result += buildMentionHtml(m.text, mentionId);
+            html = buildMentionHtml(m.text, mentionId);
             mentionId++;
         }
         else {
-            // Link
             const safeText = escapeHtml(m.text);
             const safeUrl = m.target.replace(/"/g, '"');
-            result += `<a href="${safeUrl}">${safeText}</a>`;
+            html = `<a href="${safeUrl}">${safeText}</a>`;
         }
-        lastIndex = m.index + m.length;
-    }
-    // Add remaining text with markdown conversion
-    const remaining = content.substring(lastIndex);
-    if (remaining) {
-        result += markdownToTeamsHtml(remaining);
+        placeholders.set(placeholder, html);
+        placeholderContent = placeholderContent.substring(0, m.index) + placeholder + placeholderContent.substring(m.index + m.length);
+    }
+    // Reverse mentions array since we processed in reverse order
+    mentions.reverse();
+    // Convert the whole content (with placeholders) through markdown pipeline
+    let result = markdownToTeamsHtml(placeholderContent);
+    // Substitute placeholders back with actual HTML
+    for (const [placeholder, html] of placeholders) {
+        result = result.replace(placeholder, html);
     }
     return { html: result, mentions };
 }

package/dist/api/index.d.ts

@@ -5,3 +5,4 @@ export * from './substrate-api.js';
 export * from './chatsvc-api.js';
 export * from './csa-api.js';
 export * from './calendar-api.js';
+export * from './transcript-api.js';

package/dist/api/index.js

@@ -5,3 +5,4 @@ export * from './substrate-api.js';
 export * from './chatsvc-api.js';
 export * from './csa-api.js';
 export * from './calendar-api.js';
+export * from './transcript-api.js';

package/dist/api/transcript-api.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Transcript API client for meeting transcript operations.
+ *
+ * Uses Substrate WorkingSetFiles API to fetch meeting transcripts.
+ * The transcript is embedded as JSON in the WorkingSetFiles response,
+ * using the same Substrate token already used for search.
+ *
+ * Flow: threadId → Substrate WorkingSetFiles (filter by MeetingThreadId) → parse TranscriptJson
+ */
+import { type Result } from '../types/result.js';
+import { type TranscriptEntry } from '../utils/parsers.js';
+/** Result of fetching a transcript. */
+export interface TranscriptResult {
+    /** Meeting title from the recording metadata. */
+    meetingTitle?: string;
+    /** Meeting thread ID used for the lookup. */
+    threadId: string;
+    /** When the recording started. */
+    recordingStartTime?: string;
+    /** When the recording ended. */
+    recordingEndTime?: string;
+    /** Parsed transcript entries with timestamps and speakers. */
+    entries: TranscriptEntry[];
+    /** Formatted readable transcript text. */
+    formattedText: string;
+    /** Number of transcript entries. */
+    entryCount: number;
+    /** List of unique speakers in the transcript. */
+    speakers: string[];
+}
+/**
+ * Gets the transcript for a meeting by its thread ID.
+ *
+ * Uses Substrate WorkingSetFiles to find the recording associated with the
+ * meeting thread, then extracts the embedded TranscriptJson.
+ *
+ * @param threadId - The meeting thread ID (e.g., "19:meeting_xxx@thread.v2")
+ * @param meetingDate - ISO date string of the meeting (used to narrow the search window)
+ * @returns Parsed transcript with entries and formatted text
+ */
+export declare function getTranscriptContent(threadId: string, meetingDate?: string): Promise<Result<TranscriptResult>>;

package/dist/api/transcript-api.js

@@ -0,0 +1,121 @@
+/**
+ * Transcript API client for meeting transcript operations.
+ *
+ * Uses Substrate WorkingSetFiles API to fetch meeting transcripts.
+ * The transcript is embedded as JSON in the WorkingSetFiles response,
+ * using the same Substrate token already used for search.
+ *
+ * Flow: threadId → Substrate WorkingSetFiles (filter by MeetingThreadId) → parse TranscriptJson
+ */
+import { httpRequest } from '../utils/http.js';
+import { ok, err } from '../types/result.js';
+import { ErrorCode, createError } from '../types/errors.js';
+import { requireSubstrateTokenAsync } from '../utils/auth-guards.js';
+import { formatTranscriptText } from '../utils/parsers.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────────────────────
+/** Substrate WorkingSetFiles endpoint for finding meeting recordings + transcripts. */
+const WORKING_SET_FILES_URL = 'https://substrate.office.com/api/beta/me/WorkingSetFiles/';
+/** Fields to select from WorkingSetFiles. */
+const WORKING_SET_SELECT = [
+    'SharePointItem',
+    'Visualization',
+    'ItemProperties/Default/MeetingCallId',
+    'ItemProperties/Default/DriveId',
+    'ItemProperties/Default/RecordingStartDateTime',
+    'ItemProperties/Default/RecordingEndDateTime',
+    'ItemProperties/Default/TranscriptJson',
+    'ItemProperties/Default/DocumentLink',
+].join(',');
+// ─────────────────────────────────────────────────────────────────────────────
+// API Functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Gets the transcript for a meeting by its thread ID.
+ *
+ * Uses Substrate WorkingSetFiles to find the recording associated with the
+ * meeting thread, then extracts the embedded TranscriptJson.
+ *
+ * @param threadId - The meeting thread ID (e.g., "19:meeting_xxx@thread.v2")
+ * @param meetingDate - ISO date string of the meeting (used to narrow the search window)
+ * @returns Parsed transcript with entries and formatted text
+ */
+export async function getTranscriptContent(threadId, meetingDate) {
+    const authResult = await requireSubstrateTokenAsync();
+    if (!authResult.ok)
+        return authResult;
+    const token = authResult.value;
+    // Build date filter: search ±1 day around the meeting date, or last 30 days
+    let dateFilter = '';
+    if (meetingDate) {
+        const date = new Date(meetingDate);
+        const dayBefore = new Date(date);
+        dayBefore.setDate(dayBefore.getDate() - 1);
+        const dayAfter = new Date(date);
+        dayAfter.setDate(dayAfter.getDate() + 1);
+        dateFilter = ` AND FileCreatedTime gt ${dayBefore.toISOString()} AND FileCreatedTime lt ${dayAfter.toISOString()}`;
+    }
+    const filter = `ItemProperties/Default/MeetingThreadId eq '${threadId}'${dateFilter}`;
+    const url = `${WORKING_SET_FILES_URL}?$filter=${encodeURIComponent(filter)}&$orderby=${encodeURIComponent('FileCreatedTime desc')}&$select=${encodeURIComponent(WORKING_SET_SELECT)}`;
+    const response = await httpRequest(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Prefer': 'substrate.flexibleschema,outlook.data-source="Substrate",exchange.behavior="SubstrateFiles"',
+        },
+    });
+    if (!response.ok) {
+        return response;
+    }
+    const data = response.value.data;
+    const items = data.value;
+    if (!items || items.length === 0) {
+        return err(createError(ErrorCode.NOT_FOUND, 'No recording found for this meeting. Transcription may not have been enabled, or the recording has not finished processing.', { suggestions: [
+                'Check that transcription/recording was enabled during the meeting',
+                'Wait a few minutes if the meeting just ended',
+                'The meeting organiser must have recording enabled',
+            ] }));
+    }
+    const item = items[0];
+    const props = item.ItemProperties?.Default;
+    const viz = item.Visualization;
+    // Extract TranscriptJson
+    const transcriptJsonStr = props?.TranscriptJson;
+    if (!transcriptJsonStr) {
+        return err(createError(ErrorCode.NOT_FOUND, 'Recording found but no transcript available. Transcription may not have been enabled for this meeting.', { suggestions: ['Check that transcription was enabled during the meeting'] }));
+    }
+    // Parse the transcript JSON
+    let transcriptData;
+    try {
+        transcriptData = JSON.parse(transcriptJsonStr);
+    }
+    catch {
+        return err(createError(ErrorCode.UNKNOWN, 'Failed to parse transcript data.'));
+    }
+    const rawEntries = transcriptData.entries || [];
+    if (rawEntries.length === 0) {
+        return err(createError(ErrorCode.NOT_FOUND, 'Transcript is empty — no speech was detected during the meeting.'));
+    }
+    // Map to TranscriptEntry format
+    const entries = rawEntries.map(e => ({
+        startTime: (e.startOffset || '').replace(/0{4}$/, ''),
+        endTime: (e.endOffset || '').replace(/0{4}$/, ''),
+        speaker: e.speakerDisplayName || '',
+        text: e.text || '',
+    }));
+    const formattedText = formatTranscriptText(entries);
+    const speakers = [...new Set(entries.map(e => e.speaker).filter(s => s.length > 0))];
+    return ok({
+        meetingTitle: viz?.Title,
+        threadId,
+        recordingStartTime: props?.RecordingStartDateTime,
+        recordingEndTime: props?.RecordingEndDateTime,
+        entries,
+        formattedText,
+        entryCount: entries.length,
+        speakers,
+    });
+}

package/dist/browser/auth.js

@@ -4,7 +4,6 @@
  */
 import { saveSessionState } from './context.js';
 import { OVERLAY_STEP_PAUSE_MS, OVERLAY_COMPLETE_PAUSE_MS, } from '../constants.js';
-import { extractSubstrateToken, clearTokenCache } from '../auth/token-extractor.js';
 /**
  * Default Teams URL for initial login.
  *
@@ -285,18 +284,61 @@ async function hasAuthenticatedContent(page) {
     }
     return false;
 }
+/**
+ * Waits for the Teams SPA to be fully loaded and interactive.
+ *
+ * Teams is a heavy SPA — after navigation, the shell loads quickly but MSAL
+ * (which manages tokens) needs time to bootstrap. We wait for key UI elements
+ * that only render after the app has fully initialised, then wait for network
+ * activity to settle (indicating MSAL token requests have completed).
+ */
+async function waitForTeamsReady(page, log, timeoutMs = 60000) {
+    log('Waiting for Teams to fully load...');
+    try {
+        // Wait for any SPA UI element that indicates the app has bootstrapped
+        await page.waitForSelector(AUTH_SUCCESS_SELECTORS.join(', '), { timeout: timeoutMs });
+        log('Teams UI elements detected.');
+        // Wait for network to settle — MSAL token refresh requests should complete
+        try {
+            await page.waitForLoadState('networkidle', { timeout: 15000 });
+            log('Network settled.');
+        }
+        catch {
+            // Network may not become fully idle (websockets, polling), that's OK
+            log('Network did not fully settle, continuing...');
+        }
+        return true;
+    }
+    catch {
+        log('Teams did not fully load within timeout.');
+        return false;
+    }
+}
 /**
  * Triggers MSAL to acquire the Substrate token.
  *
  * MSAL only acquires tokens for specific scopes when the app makes API calls
  * requiring those scopes. The Substrate API is only used for search, so we
- * perform a minimal search ("is:Messages") to trigger token acquisition.
+ * perform a search to trigger token acquisition.
+ *
+ * Returns true if a Substrate API call was detected, false otherwise.
  */
 async function triggerTokenAcquisition(page, log) {
     log('Triggering token acquisition...');
     try {
-        // Wait for the app to be ready
-        await page.waitForTimeout(5000);
+        // Wait for Teams SPA to be fully loaded (MSAL must bootstrap first)
+        const ready = await waitForTeamsReady(page, log);
+        if (!ready) {
+            log('Teams did not load — cannot trigger token acquisition.');
+            return false;
+        }
+        // Set up Substrate API listener BEFORE triggering search
+        let substrateDetected = false;
+        const substratePromise = page.waitForResponse(resp => resp.url().includes('substrate.office.com') && resp.status() === 200, { timeout: 30000 }).then(() => {
+            substrateDetected = true;
+        }).catch(() => {
+            // Timeout — no Substrate call detected
+        });
         // Try multiple methods to trigger search
         let searchTriggered = false;
         // Method 1: Navigate to search results URL (triggers Substrate API call directly)
@@ -306,7 +348,6 @@ async function triggerTokenAcquisition(page, log) {
                 waitUntil: 'domcontentloaded',
                 timeout: 30000,
             });
-            await page.waitForTimeout(5000);
             searchTriggered = true;
             log('Search results page loaded.');
         }
@@ -355,28 +396,31 @@ async function triggerTokenAcquisition(page, log) {
             await page.keyboard.press('Enter');
             searchTriggered = true;
         }
-        // Wait for the Substrate search API call to complete
-        log('Waiting for search API...');
-        try {
-            // Wait for the actual API request to substrate.office.com
-            await Promise.race([
-                page.waitForResponse(resp => resp.url().includes('substrate.office.com') && resp.status() === 200, { timeout: 15000 }),
-                page.waitForTimeout(15000),
-            ]);
-            log('Substrate API call detected.');
+        // Wait for the Substrate API response
+        log('Waiting for Substrate API...');
+        await substratePromise;
+        if (substrateDetected) {
+            log('Substrate API call detected — tokens acquired.');
         }
-        catch {
-            log('No Substrate API call detected, continuing...');
+        else {
+            log('No Substrate API call detected within timeout.');
         }
+        // Give MSAL a moment to persist tokens to localStorage
         await page.waitForTimeout(2000);
         // Close search and reset
-        await page.keyboard.press('Escape');
-        await page.waitForTimeout(1000);
+        try {
+            await page.keyboard.press('Escape');
+            await page.waitForTimeout(500);
+        }
+        catch {
+            // Page may have navigated, ignore
+        }
         log('Token acquisition complete.');
+        return substrateDetected;
     }
     catch (error) {
         log(`Token acquisition warning: ${error instanceof Error ? error.message : String(error)}`);
-        await page.waitForTimeout(3000);
+        return false;
     }
 }
 /**
@@ -517,23 +561,20 @@ export async function waitForManualLogin(page, context, timeoutMs = 5 * 60 * 100
                 await showLoginProgress(page, 'acquiring');
             }
             // Trigger a search to cause MSAL to acquire the Substrate token
-            await triggerTokenAcquisition(page, log);
+            const acquired = await triggerTokenAcquisition(page, log);
+            if (!acquired) {
+                log('Warning: Substrate API call was not detected after login.');
+                if (showOverlay) {
+                    await showLoginProgress(page, 'error', { pause: true });
+                }
+                throw new Error('Login completed but token acquisition failed. Please try again.');
+            }
             if (showOverlay) {
                 await showLoginProgress(page, 'saving');
             }
             // Save the session state with fresh tokens
             await saveSessionState(context);
-            clearTokenCache();
             log('Session state saved.');
-            // Verify tokens were actually acquired
-            const token = extractSubstrateToken();
-            if (!token || token.expiry.getTime() <= Date.now()) {
-                log('Warning: No valid Substrate token found after login. You may need to try again.');
-                if (showOverlay) {
-                    await showLoginProgress(page, 'error', { pause: true });
-                }
-                throw new Error('Login completed but token acquisition failed. Please try again.');
-            }
             if (showOverlay) {
                 await showLoginProgress(page, 'complete', { pause: true });
             }
@@ -566,39 +607,23 @@ export async function ensureAuthenticated(page, context, onProgress, showOverlay
     const status = await navigateToTeams(page);
     if (status.isAuthenticated) {
         log('Already authenticated.');
-        // Snapshot token expiry before refresh attempt
-        const beforeToken = extractSubstrateToken();
-        const beforeExpiry = beforeToken?.expiry?.getTime() ?? 0;
         if (showOverlay) {
             await showLoginProgress(page, 'refreshing');
         }
         // Trigger a search to cause MSAL to acquire/refresh the Substrate token
-        await triggerTokenAcquisition(page, log);
+        const acquired = await triggerTokenAcquisition(page, log);
+        if (!acquired) {
+            log('Token refresh failed: Substrate API call was not detected.');
+            if (showOverlay) {
+                await showLoginProgress(page, 'error', { pause: true });
+            }
+            throw new Error('Token refresh failed. Please use teams_login with forceNew to re-authenticate.');
+        }
         if (showOverlay) {
             await showLoginProgress(page, 'saving');
         }
         // Save the session state with fresh tokens
         await saveSessionState(context);
-        // Clear token cache so we re-extract from the freshly saved session
-        clearTokenCache();
-        // Verify tokens were actually refreshed
-        const afterToken = extractSubstrateToken();
-        const afterExpiry = afterToken?.expiry?.getTime() ?? 0;
-        const tokenIsValid = afterToken !== null && afterExpiry > Date.now();
-        const tokenWasRefreshed = afterExpiry > beforeExpiry;
-        if (!tokenIsValid) {
-            log('Warning: No valid token found after refresh attempt.');
-            if (headless) {
-                throw new Error('Token refresh failed: no valid token after SSO. Browser-based re-authentication required.');
-            }
-        }
-        else if (!tokenWasRefreshed && beforeToken && beforeExpiry <= Date.now() + 10 * 60 * 1000) {
-            // Token was close to expiry but wasn't refreshed - MSAL likely didn't initialise in time
-            log('Warning: Token was not refreshed despite being close to expiry.');
-            if (headless) {
-                throw new Error('Token refresh failed: token not refreshed despite being close to expiry. Browser-based re-authentication required.');
-            }
-        }
         if (showOverlay) {
             await showLoginProgress(page, 'complete', { pause: true });
         }

package/dist/research/explore.js

@@ -11,18 +11,14 @@
 import { chromium } from 'playwright';
 import * as fs from 'fs';
 import * as path from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = path.resolve(__dirname, '../..');
-const USER_DATA_DIR = path.join(PROJECT_ROOT, '.user-data');
-const SESSION_STATE_PATH = path.join(PROJECT_ROOT, 'session-state.json');
+import { PROJECT_ROOT, USER_DATA_DIR, readSessionState, writeSessionState, } from '../auth/session-store.js';
 const FINDINGS_PATH = path.join(PROJECT_ROOT, 'research-findings.json');
 // Track interesting API calls
 const capturedNetworkData = {
     requests: [],
     responses: [],
 };
-// Patterns that indicate search-related API calls
+// Patterns that indicate interesting API calls
 const SEARCH_PATTERNS = [
     /search/i,
     /query/i,
@@ -32,6 +28,13 @@ const SEARCH_PATTERNS = [
     /teams.*api/i,
     /chatservice/i,
     /emea\.ng\.msg/i,
+    /transcript/i,
+    /recording/i,
+    /onlineMeeting/i,
+    /callRecord/i,
+    /\.vtt/i,
+    /asyncgw/i,
+    /mediaservice/i,
 ];
 function isInterestingUrl(url) {
     // Skip static assets, telemetry, and auth-related noise
@@ -90,7 +93,7 @@ async function captureResponse(response) {
     let body;
     try {
         const contentType = response.headers()['content-type'] || '';
-        if (contentType.includes('application/json')) {
+        if (contentType.includes('application/json') || contentType.includes('text/vtt') || contentType.includes('text/plain')) {
             body = await response.text();
         }
     }
@@ -190,15 +193,17 @@ async function main() {
     let context;
     try {
         // Launch browser with persistent context
+        const channel = process.platform === 'win32' ? 'msedge' : 'chrome';
         browser = await chromium.launch({
             headless: false, // Must be visible for manual login
+            channel,
         });
-        // Check if we have saved session state
-        const hasSessionState = fs.existsSync(SESSION_STATE_PATH);
-        if (hasSessionState) {
+        // Check if we have saved session state (uses encrypted store)
+        const existingState = readSessionState();
+        if (existingState) {
             console.log('📂 Found existing session state, attempting to restore...');
             context = await browser.newContext({
-                storageState: SESSION_STATE_PATH,
+                storageState: existingState,
                 viewport: { width: 1280, height: 800 },
             });
         }
@@ -221,7 +226,8 @@ async function main() {
             await waitForAuthentication(page);
             // Save session state after successful authentication
             console.log('💾 Saving session state...');
-            await context.storageState({ path: SESSION_STATE_PATH });
+            const state = await context.storageState();
+            writeSessionState(state);
             console.log('✅ Session state saved!');
         }
         else {
@@ -246,23 +252,34 @@ async function main() {
                 resolve();
             });
         });
-        // Save session state before closing
-        console.log('💾 Saving final session state...');
-        await context.storageState({ path: SESSION_STATE_PATH });
-        // Save research findings
+        // Save research findings FIRST (before browser might close)
         await saveFindings();
+        // Try to save session state (may fail if browser already closed)
+        try {
+            console.log('💾 Saving final session state...');
+            const finalState = await context.storageState();
+            writeSessionState(finalState);
+        }
+        catch {
+            console.log('⚠️  Could not save session state (browser already closed)');
+        }
     }
     catch (error) {
+        // Still try to save findings on error
+        await saveFindings();
         console.error('❌ Error:', error);
-        throw error;
     }
     finally {
-        if (context) {
-            await context.close();
+        try {
+            if (context)
+                await context.close();
         }
-        if (browser) {
-            await browser.close();
+        catch { /* already closed */ }
+        try {
+            if (browser)
+                await browser.close();
         }
+        catch { /* already closed */ }
     }
     console.log('\n✅ Research session complete!');
     console.log(`   Review findings in: ${FINDINGS_PATH}`);

package/dist/test/dump-tokens.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env tsx
+/**
+ * Quick diagnostic: dump all MSAL token targets from the session.
+ * Run: npm run build && node dist/test/dump-tokens.js
+ * Or:  npx tsx src/test/dump-tokens.ts
+ */
+export {};

package/dist/test/dump-tokens.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env tsx
+/**
+ * Quick diagnostic: dump all MSAL token targets from the session.
+ * Run: npm run build && node dist/test/dump-tokens.js
+ * Or:  npx tsx src/test/dump-tokens.ts
+ */
+import { readSessionState, getTeamsOrigin } from '../auth/session-store.js';
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length < 2)
+            return null;
+        return JSON.parse(Buffer.from(parts[1], 'base64').toString());
+    }
+    catch {
+        return null;
+    }
+}
+const sessionState = readSessionState();
+if (!sessionState) {
+    console.log('No session state found. Run teams_login first.');
+    process.exit(1);
+}
+const teamsOrigin = getTeamsOrigin(sessionState);
+const localStorage = teamsOrigin?.localStorage ?? [];
+console.log(`Found ${localStorage.length} localStorage entries\n`);
+// Collect all tokens with their targets
+const tokens = [];
+for (const item of localStorage) {
+    try {
+        const entry = JSON.parse(item.value);
+        const target = entry.target;
+        const secret = entry.secret;
+        if (!target || !secret || !secret.startsWith('ey'))
+            continue;
+        const payload = decodeJwtPayload(secret);
+        if (!payload?.exp || typeof payload.exp !== 'number')
+            continue;
+        const expiry = new Date(payload.exp * 1000);
+        const minutesLeft = Math.round((expiry.getTime() - Date.now()) / 1000 / 60);
+        // Extract scopes from the token's scp claim
+        const scp = payload.scp;
+        const scopes = scp ? scp.split(' ') : [];
+        tokens.push({
+            target,
+            scopes,
+            expiry: expiry.toISOString(),
+            minutesLeft,
+            hasGraph: target.includes('graph.microsoft.com'),
+        });
+    }
+    catch {
+        continue;
+    }
+}
+console.log('=== ALL MSAL TOKENS ===\n');
+for (const t of tokens) {
+    const status = t.minutesLeft > 0 ? `✅ ${t.minutesLeft}m left` : '❌ EXPIRED';
+    console.log(`Target: ${t.target}`);
+    console.log(`Status: ${status}`);
+    if (t.scopes.length > 0) {
+        console.log(`Scopes: ${t.scopes.join(', ')}`);
+    }
+    console.log();
+}
+// Highlight Graph tokens
+const graphTokens = tokens.filter(t => t.hasGraph);
+console.log('=== GRAPH TOKENS ===\n');
+if (graphTokens.length === 0) {
+    console.log('⚠️  No graph.microsoft.com tokens found in session.');
+    console.log('   The Teams web app may not store Graph tokens in localStorage.');
+    console.log('   Transcript API will need to use the middle tier instead.');
+}
+else {
+    for (const t of graphTokens) {
+        console.log(`Target: ${t.target}`);
+        console.log(`Scopes: ${t.scopes.join(', ')}`);
+        console.log(`Expiry: ${t.expiry} (${t.minutesLeft}m left)`);
+        const hasTranscriptScope = t.scopes.some(s => s.toLowerCase().includes('transcript') ||
+            s.toLowerCase().includes('onlinemeeting'));
+        if (hasTranscriptScope) {
+            console.log('✅ Has transcript-related scopes!');
+        }
+        else {
+            console.log('⚠️  No transcript-specific scopes found in this token.');
+            console.log('   May still work if the first-party Teams app has implicit access.');
+        }
+        console.log();
+    }
+}

package/dist/test/test-transcript.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+/**
+ * Test the transcript API end-to-end.
+ * Run: npx tsx src/test/test-transcript.ts
+ */
+export {};

package/dist/test/test-transcript.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env tsx
+/**
+ * Test the transcript API end-to-end.
+ * Run: npx tsx src/test/test-transcript.ts
+ */
+import { getCalendarView } from '../api/calendar-api.js';
+import { getTranscriptContent } from '../api/transcript-api.js';
+async function main() {
+    console.log('=== Get recent meetings with threadId ===');
+    const now = new Date();
+    const pastWeek = new Date(now);
+    pastWeek.setDate(pastWeek.getDate() - 14);
+    const meetingsResult = await getCalendarView({
+        startDate: pastWeek.toISOString(),
+        endDate: now.toISOString(),
+        limit: 50,
+    });
+    if (!meetingsResult.ok) {
+        console.log(`❌ ${meetingsResult.error.message}`);
+        process.exit(1);
+    }
+    const meetings = meetingsResult.value.meetings.filter(m => m.threadId);
+    console.log(`Found ${meetings.length} meetings with threadId\n`);
+    // Try each meeting until we find one with a transcript
+    for (const meeting of meetings.slice(0, 10)) {
+        console.log(`--- "${meeting.subject}" (${meeting.startTime}) ---`);
+        console.log(`Thread: ${meeting.threadId}`);
+        const result = await getTranscriptContent(meeting.threadId, meeting.startTime);
+        if (result.ok) {
+            console.log(`\n✅ SUCCESS!`);
+            console.log(`Title: ${result.value.meetingTitle}`);
+            console.log(`Speakers: ${result.value.speakers.join(', ')}`);
+            console.log(`Entries: ${result.value.entryCount}`);
+            console.log(`Recording: ${result.value.recordingStartTime} → ${result.value.recordingEndTime}`);
+            console.log(`\nFirst 800 chars:\n${result.value.formattedText.substring(0, 800)}`);
+            process.exit(0);
+        }
+        else {
+            console.log(`  ❌ ${result.error.code}: ${result.error.message}\n`);
+        }
+    }
+    console.log('No transcripts found for any recent meeting.');
+}
+main().catch(e => {
+    console.error('Fatal error:', e);
+    process.exit(1);
+});

package/dist/tools/meeting-tools.d.ts

@@ -16,9 +16,20 @@ export declare const GetMeetingsInputSchema: z.ZodObject<{
     startDate?: string | undefined;
     endDate?: string | undefined;
 }>;
+export declare const GetTranscriptInputSchema: z.ZodObject<{
+    threadId: z.ZodString;
+    meetingDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    threadId: string;
+    meetingDate?: string | undefined;
+}, {
+    threadId: string;
+    meetingDate?: string | undefined;
+}>;
 export declare const getMeetingsTool: RegisteredTool<typeof GetMeetingsInputSchema>;
+export declare const getTranscriptTool: RegisteredTool<typeof GetTranscriptInputSchema>;
 /** All meeting-related tools. */
-export declare const meetingTools: RegisteredTool<z.ZodObject<{
+export declare const meetingTools: (RegisteredTool<z.ZodObject<{
     startDate: z.ZodOptional<z.ZodString>;
     endDate: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -30,4 +41,13 @@ export declare const meetingTools: RegisteredTool<z.ZodObject<{
     limit?: number | undefined;
     startDate?: string | undefined;
     endDate?: string | undefined;
-}>>[];
+}>> | RegisteredTool<z.ZodObject<{
+    threadId: z.ZodString;
+    meetingDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    threadId: string;
+    meetingDate?: string | undefined;
+}, {
+    threadId: string;
+    meetingDate?: string | undefined;
+}>>)[];

package/dist/tools/meeting-tools.js

@@ -4,6 +4,7 @@
 import { z } from 'zod';
 import { handleApiResult } from './index.js';
 import { getCalendarView } from '../api/calendar-api.js';
+import { getTranscriptContent } from '../api/transcript-api.js';
 import { DEFAULT_MEETING_LIMIT, MAX_MEETING_LIMIT, } from '../constants.js';
 // ─────────────────────────────────────────────────────────────────────────────
 // Schemas
@@ -13,6 +14,10 @@ export const GetMeetingsInputSchema = z.object({
     endDate: z.string().optional(),
     limit: z.number().min(1).max(MAX_MEETING_LIMIT).optional().default(DEFAULT_MEETING_LIMIT),
 });
+export const GetTranscriptInputSchema = z.object({
+    threadId: z.string(),
+    meetingDate: z.string().optional(),
+});
 // ─────────────────────────────────────────────────────────────────────────────
 // Tool Definitions
 // ─────────────────────────────────────────────────────────────────────────────
@@ -53,6 +58,36 @@ async function handleGetMeetings(input, _ctx) {
     }));
 }
 // ─────────────────────────────────────────────────────────────────────────────
+// Transcript Tool
+// ─────────────────────────────────────────────────────────────────────────────
+const getTranscriptToolDefinition = {
+    name: 'teams_get_transcript',
+    description: 'Get the transcript of a Teams meeting. Requires the meeting\'s threadId (from teams_get_meetings). Returns the full transcript with timestamps and speakers, formatted as readable text. The meeting must have had transcription enabled. Optionally pass meetingDate (ISO string, e.g. the startTime from teams_get_meetings) to narrow the search.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            threadId: {
+                type: 'string',
+                description: 'The meeting thread ID (from the threadId field of teams_get_meetings results, e.g., "19:meeting_xxx@thread.v2").',
+            },
+            meetingDate: {
+                type: 'string',
+                description: 'Optional ISO date/time of the meeting (e.g., the startTime from teams_get_meetings). Helps narrow the search for recurring meetings.',
+            },
+        },
+        required: ['threadId'],
+    },
+};
+async function handleGetTranscript(input, _ctx) {
+    const result = await getTranscriptContent(input.threadId, input.meetingDate);
+    return handleApiResult(result, (value) => ({
+        meetingTitle: value.meetingTitle,
+        speakers: value.speakers,
+        entryCount: value.entryCount,
+        transcript: value.formattedText,
+    }));
+}
+// ─────────────────────────────────────────────────────────────────────────────
 // Exports
 // ─────────────────────────────────────────────────────────────────────────────
 export const getMeetingsTool = {
@@ -60,5 +95,10 @@ export const getMeetingsTool = {
     schema: GetMeetingsInputSchema,
     handler: handleGetMeetings,
 };
+export const getTranscriptTool = {
+    definition: getTranscriptToolDefinition,
+    schema: GetTranscriptInputSchema,
+    handler: handleGetTranscript,
+};
 /** All meeting-related tools. */
-export const meetingTools = [getMeetingsTool];
+export const meetingTools = [getMeetingsTool, getTranscriptTool];

package/dist/utils/parsers.d.ts

@@ -266,3 +266,24 @@ export interface VirtualConversationItem {
  * @returns Parsed virtual conversation item, or null if message should be skipped
  */
 export declare function parseVirtualConversationMessage(msg: Record<string, unknown>, referencePattern: RegExp): VirtualConversationItem | null;
+/** A single entry from a meeting transcript. */
+export interface TranscriptEntry {
+    /** Start time (e.g., "00:00:22.287"). */
+    startTime: string;
+    /** End time (e.g., "00:00:23.167"). */
+    endTime: string;
+    /** Speaker display name. */
+    speaker: string;
+    /** Spoken text content. */
+    text: string;
+}
+/**
+ * Formats transcript entries into a readable text format.
+ *
+ * Merges consecutive entries from the same speaker into a single block
+ * to reduce noise and improve readability.
+ *
+ * @param entries - Transcript entries
+ * @returns Formatted transcript string
+ */
+export declare function formatTranscriptText(entries: TranscriptEntry[]): string;

package/dist/utils/parsers.js

@@ -878,3 +878,45 @@ export function parseVirtualConversationMessage(msg, referencePattern) {
         links: links.length > 0 ? links : undefined,
     };
 }
+/**
+ * Formats transcript entries into a readable text format.
+ *
+ * Merges consecutive entries from the same speaker into a single block
+ * to reduce noise and improve readability.
+ *
+ * @param entries - Transcript entries
+ * @returns Formatted transcript string
+ */
+export function formatTranscriptText(entries) {
+    if (entries.length === 0)
+        return '';
+    const blocks = [];
+    let currentSpeaker = null;
+    let currentTexts = [];
+    let blockStartTime = '';
+    for (const entry of entries) {
+        if (entry.speaker !== currentSpeaker) {
+            // Flush previous block
+            if (currentTexts.length > 0) {
+                const prefix = currentSpeaker
+                    ? `[${blockStartTime}] ${currentSpeaker}:`
+                    : `[${blockStartTime}]`;
+                blocks.push(`${prefix}\n${currentTexts.join(' ')}`);
+            }
+            currentSpeaker = entry.speaker;
+            currentTexts = [entry.text];
+            blockStartTime = entry.startTime;
+        }
+        else {
+            currentTexts.push(entry.text);
+        }
+    }
+    // Flush last block
+    if (currentTexts.length > 0) {
+        const prefix = currentSpeaker
+            ? `[${blockStartTime}] ${currentSpeaker}:`
+            : `[${blockStartTime}]`;
+        blocks.push(`${prefix}\n${currentTexts.join(' ')}`);
+    }
+    return blocks.join('\n\n');
+}

package/dist/utils/parsers.test.js

@@ -5,7 +5,7 @@
  * produce expected outputs regardless of internal logic.
  */
 import { describe, it, expect } from 'vitest';
-import { stripHtml, extractLinks, buildMessageLink, getConversationType, extractMessageTimestamp, parsePersonSuggestion, parseV2Result, parseJwtProfile, calculateTokenStatus, parseSearchResults, parsePeopleResults, extractObjectId, buildOneOnOneConversationId, decodeBase64Guid, extractActivityTimestamp, markdownToTeamsHtml, } from './parsers.js';
+import { stripHtml, extractLinks, buildMessageLink, getConversationType, extractMessageTimestamp, parsePersonSuggestion, parseV2Result, parseJwtProfile, calculateTokenStatus, parseSearchResults, parsePeopleResults, extractObjectId, buildOneOnOneConversationId, decodeBase64Guid, extractActivityTimestamp, markdownToTeamsHtml, formatTranscriptText, } from './parsers.js';
 import { searchResultItem, searchResultWithHtml, searchResultMinimal, searchResultTooShort, searchResultThreadReply, searchEntitySetsResponse, personSuggestion, personMinimal, personWithBase64Id, peopleGroupsResponse, jwtPayloadFull, jwtPayloadMinimal, jwtPayloadCommaName, jwtPayloadSpaceName, sourceWithMessageId, sourceWithConvIdMessageId, } from '../__fixtures__/api-responses.js';
 describe('stripHtml', () => {
     it('removes HTML tags', () => {
@@ -581,3 +581,32 @@ describe('markdownToTeamsHtml', () => {
         expect(markdownToTeamsHtml('   ')).toBe('<p></p>');
     });
 });
+describe('formatTranscriptText', () => {
+    it('formats entries with speaker names and timestamps', () => {
+        const entries = [
+            { startTime: '00:00:01.000', endTime: '00:00:05.000', speaker: 'Alice', text: 'Hello everyone.' },
+            { startTime: '00:00:06.000', endTime: '00:00:10.000', speaker: 'Bob', text: 'Hi Alice!' },
+        ];
+        const result = formatTranscriptText(entries);
+        expect(result).toBe('[00:00:01.000] Alice:\nHello everyone.\n\n[00:00:06.000] Bob:\nHi Alice!');
+    });
+    it('merges consecutive entries from the same speaker', () => {
+        const entries = [
+            { startTime: '00:00:01.000', endTime: '00:00:03.000', speaker: 'Alice', text: 'First part.' },
+            { startTime: '00:00:03.000', endTime: '00:00:06.000', speaker: 'Alice', text: 'Second part.' },
+            { startTime: '00:00:07.000', endTime: '00:00:10.000', speaker: 'Bob', text: 'Response.' },
+        ];
+        const result = formatTranscriptText(entries);
+        expect(result).toBe('[00:00:01.000] Alice:\nFirst part. Second part.\n\n[00:00:07.000] Bob:\nResponse.');
+    });
+    it('handles entries without speaker names', () => {
+        const entries = [
+            { startTime: '00:00:01.000', endTime: '00:00:05.000', speaker: '', text: 'Unknown speaker.' },
+        ];
+        const result = formatTranscriptText(entries);
+        expect(result).toBe('[00:00:01.000]\nUnknown speaker.');
+    });
+    it('returns empty string for empty entries', () => {
+        expect(formatTranscriptText([])).toBe('');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msteams-mcp",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "MCP server for Microsoft Teams - search messages, send replies, manage favourites",
   "type": "module",
   "main": "dist/index.js",