msteams-mcp 0.30.0 → 0.30.2

package/dist/api/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * API module exports.
+ */
+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';
+export * from './files-api.js';
+export * from './tags-api.js';

package/dist/api/index.js

@@ -0,0 +1,10 @@
+/**
+ * API module exports.
+ */
+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';
+export * from './files-api.js';
+export * from './tags-api.js';

package/dist/auth/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Auth module exports.
+ */
+export * from './session-store.js';
+export * from './token-extractor.js';
+export * from './token-refresh.js';
+export { encrypt, decrypt, isEncrypted, type EncryptedData } from './crypto.js';

package/dist/auth/index.js

@@ -0,0 +1,7 @@
+/**
+ * Auth module exports.
+ */
+export * from './session-store.js';
+export * from './token-extractor.js';
+export * from './token-refresh.js';
+export { encrypt, decrypt, isEncrypted } from './crypto.js';

package/dist/auth/session-store.d.ts

@@ -63,6 +63,11 @@ export declare function writeSessionState(state: SessionState): void;
  * Deletes the session state file.
  */
 export declare function clearSessionState(): void;
+/**
+ * Deletes everything stored locally: browser profile (cookies, MSAL caches,
+ * every account ever signed in), session state and token cache.
+ */
+export declare function clearAllLocalData(): void;
 /**
  * Gets the age of the session state in hours.
  */

package/dist/auth/session-store.js

@@ -86,6 +86,13 @@ export function clearSessionState() {
         fs.unlinkSync(SESSION_STATE_PATH);
     }
 }
+/**
+ * Deletes everything stored locally: browser profile (cookies, MSAL caches,
+ * every account ever signed in), session state and token cache.
+ */
+export function clearAllLocalData() {
+    fs.rmSync(CONFIG_DIR, { recursive: true, force: true });
+}
 /**
  * Gets the age of the session state in hours.
  */

package/dist/browser/auth.js

@@ -386,7 +386,7 @@ export async function ensureAuthenticated(page, context, onProgress, showOverlay
     log('Navigating to Teams...');
     const status = await navigateToTeams(page);
     if (status.isAuthenticated) {
-        log('Already authenticated — saving session state.');
+        log('Teams loaded — saving session state.');
         await saveSessionState(context);
         // Check if the saved tokens are actually valid
         // Browser session cookies can outlive MSAL tokens (cookies last days, tokens ~1 hour)
@@ -407,9 +407,11 @@ export async function ensureAuthenticated(page, context, onProgress, showOverlay
             // Still no valid tokens after waiting
             throw new Error('Headless SSO failed: MSAL token refresh timed out');
         }
-        // In visible mode, the tokens might refresh while user interacts, or they can
-        // manually complete any prompts. We've saved what we have.
-        log('Session state saved (tokens may need refresh).');
+        // No redirect to login does not mean signed in: Teams can render with the
+        // Microsoft SSO session gone and only a dead SPA refresh token in its cache.
+        // Keep the window open until a live token appears (silently or by sign-in).
+        log('Tokens expired. Sign in in the browser window if prompted.');
+        await waitForManualLogin(page, context, onProgress, showOverlay);
         return;
     }
     // User interaction required - fail fast if headless

package/dist/browser/auth.test.js

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 vi.mock('./context.js', () => ({ saveSessionState: vi.fn() }));
 vi.mock('../auth/token-extractor.js', () => ({ extractSubstrateToken: vi.fn() }));
-import { getAuthStatus, isTeamsUrl } from './auth.js';
+import { ensureAuthenticated, getAuthStatus, isTeamsUrl } from './auth.js';
 /** A page on `url` with no Teams DOM markers and `tokenMinutes` left on MSAL. */
 function fakePage(url, tokenMinutes) {
     return {
@@ -43,3 +43,22 @@ describe('getAuthStatus', () => {
         expect(status).toMatchObject({ isAuthenticated: false, isOnLoginPage: true });
     });
 });
+describe('ensureAuthenticated', () => {
+    it('keeps a visible browser open for sign-in when Teams loads with expired tokens', async () => {
+        // Teams can render without redirecting to login while the Microsoft SSO
+        // session is gone; only a fresh MSAL token proves the user has signed in.
+        const tokenMinutes = [-1, -1, 55];
+        const page = {
+            goto: async () => null,
+            waitForURL: async () => { throw new Error('timeout'); },
+            url: () => 'https://teams.cloud.microsoft/',
+            evaluate: async () => tokenMinutes.length > 1 ? tokenMinutes.shift() : tokenMinutes[0],
+            waitForTimeout: async () => { },
+        };
+        const messages = [];
+        await ensureAuthenticated(page, {}, msg => messages.push(msg), false, false);
+        expect(messages).toContain('Waiting for manual login...');
+        expect(messages).toContain('Authentication successful!');
+        expect(tokenMinutes).toEqual([55]);
+    });
+});

package/dist/research/auth-research.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Research script to understand Teams authentication redirect behaviour.
+ *
+ * This script observes:
+ * 1. What happens when navigating to Teams WITH a valid session
+ * 2. What happens when navigating to Teams WITHOUT a session
+ *
+ * Goal: Understand the fastest way to detect if we're authenticated.
+ */
+export {};

package/dist/research/auth-research.js

@@ -0,0 +1,175 @@
+/**
+ * Research script to understand Teams authentication redirect behaviour.
+ *
+ * This script observes:
+ * 1. What happens when navigating to Teams WITH a valid session
+ * 2. What happens when navigating to Teams WITHOUT a session
+ *
+ * Goal: Understand the fastest way to detect if we're authenticated.
+ */
+import { chromium } from 'playwright';
+import { hasSessionState } from '../auth/session-store.js';
+const TEAMS_URL = 'https://teams.microsoft.com';
+async function observeNavigation(page, scenario, startTime) {
+    const events = [];
+    const log = (type, url, extra) => {
+        const now = Date.now();
+        const event = {
+            timestamp: now,
+            elapsed: now - startTime,
+            type,
+            url,
+            ...extra,
+        };
+        events.push(event);
+        console.log(`  [${event.elapsed}ms] ${type}: ${url}${extra?.status ? ` (${extra.status})` : ''}${extra?.note ? ` - ${extra.note}` : ''}`);
+    };
+    // Track all frame navigations
+    page.on('framenavigated', (frame) => {
+        if (frame === page.mainFrame()) {
+            const url = frame.url();
+            const isLogin = url.includes('login.microsoftonline.com') ||
+                url.includes('login.live.com') ||
+                url.includes('login.microsoft.com');
+            const isTeams = url.includes('teams.microsoft.com') ||
+                url.includes('teams.microsoft.us');
+            log('navigation', url, {
+                note: isLogin ? 'LOGIN PAGE' : isTeams ? 'TEAMS' : undefined
+            });
+        }
+    });
+    // Track responses (especially redirects)
+    page.on('response', (response) => {
+        const url = response.url();
+        const status = response.status();
+        // Only log main document responses and redirects
+        if (response.request().resourceType() === 'document' ||
+            (status >= 300 && status < 400)) {
+            log('response', url, {
+                status,
+                note: status >= 300 && status < 400 ? 'REDIRECT' : undefined
+            });
+        }
+    });
+    return events;
+}
+async function runScenario(browser, scenario, useSession) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`SCENARIO: ${scenario}`);
+    console.log(`Session: ${useSession ? 'WITH existing session' : 'NO session (cleared)'}`);
+    console.log('='.repeat(60));
+    let context;
+    if (useSession && hasSessionState()) {
+        console.log('Loading existing session state...');
+        // Handle encrypted session
+        try {
+            const { readSessionState } = await import('../auth/session-store.js');
+            const state = readSessionState();
+            if (state) {
+                context = await browser.newContext({
+                    storageState: state,
+                    viewport: { width: 1280, height: 800 },
+                });
+            }
+            else {
+                throw new Error('Could not read session');
+            }
+        }
+        catch {
+            console.log('Could not load session, using fresh context');
+            context = await browser.newContext({
+                viewport: { width: 1280, height: 800 },
+            });
+        }
+    }
+    else {
+        console.log('Using fresh context (no session)...');
+        context = await browser.newContext({
+            viewport: { width: 1280, height: 800 },
+        });
+    }
+    const page = await context.newPage();
+    const startTime = Date.now();
+    console.log(`\nNavigating to ${TEAMS_URL}...`);
+    console.log('Watching for navigations and redirects:\n');
+    const events = await observeNavigation(page, scenario, startTime);
+    try {
+        // Navigate and wait for initial load
+        await page.goto(TEAMS_URL, {
+            waitUntil: 'domcontentloaded',
+            timeout: 30000,
+        });
+        const afterGoto = Date.now();
+        console.log(`\n  [${afterGoto - startTime}ms] goto() completed (domcontentloaded)`);
+        // Wait a bit more to see if any late redirects happen
+        console.log('\n  Waiting 10 seconds to observe any delayed redirects...\n');
+        for (let i = 1; i <= 10; i++) {
+            await page.waitForTimeout(1000);
+            const currentUrl = page.url();
+            const isLogin = currentUrl.includes('login.microsoftonline.com') ||
+                currentUrl.includes('login.live.com') ||
+                currentUrl.includes('login.microsoft.com');
+            const isTeams = currentUrl.includes('teams.microsoft.com') ||
+                currentUrl.includes('teams.microsoft.us');
+            console.log(`  [${Date.now() - startTime}ms] Check ${i}: ${isLogin ? 'ON LOGIN' : isTeams ? 'ON TEAMS' : 'OTHER'} - ${currentUrl.substring(0, 80)}...`);
+            // If we're on login page, we know we're not authenticated
+            if (isLogin) {
+                console.log('\n  ✓ Detected redirect to login page - NOT authenticated');
+                break;
+            }
+        }
+        const finalUrl = page.url();
+        const duration = Date.now() - startTime;
+        console.log(`\n${'─'.repeat(60)}`);
+        console.log(`RESULT for "${scenario}":`);
+        console.log(`  Final URL: ${finalUrl}`);
+        console.log(`  Total duration: ${duration}ms`);
+        console.log(`  Navigation events: ${events.length}`);
+        const isOnLogin = finalUrl.includes('login.microsoftonline.com') ||
+            finalUrl.includes('login.live.com') ||
+            finalUrl.includes('login.microsoft.com');
+        const isOnTeams = finalUrl.includes('teams.microsoft.com') ||
+            finalUrl.includes('teams.microsoft.us');
+        console.log(`  Authenticated: ${isOnTeams && !isOnLogin ? 'YES (on Teams)' : 'NO (on login page)'}`);
+        return { events, finalUrl, duration };
+    }
+    finally {
+        await context.close();
+    }
+}
+async function main() {
+    console.log('🔬 Teams Authentication Research');
+    console.log('================================\n');
+    console.log('This script observes redirect behaviour during Teams navigation.\n');
+    const browser = await chromium.launch({
+        headless: false, // Visible so we can see what's happening
+    });
+    try {
+        // Scenario 1: With existing session (if available)
+        if (hasSessionState()) {
+            await runScenario(browser, 'WITH SESSION', true);
+        }
+        else {
+            console.log('\n⚠️  No existing session found. Run `npm run cli -- login` first to create one.');
+            console.log('   Skipping "WITH SESSION" scenario.\n');
+        }
+        // Scenario 2: Without session (cleared context)
+        await runScenario(browser, 'WITHOUT SESSION', false);
+        console.log('\n\n' + '='.repeat(60));
+        console.log('SUMMARY');
+        console.log('='.repeat(60));
+        console.log(`
+Key observations to look for:
+1. How quickly does the redirect to login.microsoftonline.com happen?
+2. Does the redirect happen BEFORE or AFTER domcontentloaded?
+3. Are there any intermediate URLs?
+4. What HTTP status codes are used for redirects?
+
+Based on this, we can tune LOGIN_REDIRECT_TIMEOUT_MS in auth.ts
+`);
+    }
+    finally {
+        await browser.close();
+    }
+}
+main().catch(console.error);

package/dist/research/explore.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Research script to explore Teams web app behaviour.
+ *
+ * This script:
+ * 1. Launches a browser with persistent context
+ * 2. Navigates to Teams and handles authentication
+ * 3. Monitors network requests to discover API endpoints
+ * 4. Allows manual interaction to trigger searches
+ * 5. Logs discovered endpoints and data structures
+ */
+export {};

package/dist/research/explore.js

@@ -0,0 +1,287 @@
+/**
+ * Research script to explore Teams web app behaviour.
+ *
+ * This script:
+ * 1. Launches a browser with persistent context
+ * 2. Navigates to Teams and handles authentication
+ * 3. Monitors network requests to discover API endpoints
+ * 4. Allows manual interaction to trigger searches
+ * 5. Logs discovered endpoints and data structures
+ */
+import { chromium } from 'playwright';
+import * as fs from 'fs';
+import * as path from 'path';
+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 interesting API calls
+const SEARCH_PATTERNS = [
+    /search/i,
+    /query/i,
+    /find/i,
+    /substrate/i,
+    /graph\.microsoft/i,
+    /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
+    const skipPatterns = [
+        /\.(js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|ico)(\?|$)/i,
+        /telemetry/i,
+        /analytics/i,
+        /logging/i,
+        /beacon/i,
+        /\.clarity\./i,
+        /fonts\./i,
+        /static/i,
+    ];
+    if (skipPatterns.some(pattern => pattern.test(url))) {
+        return false;
+    }
+    // Include if it matches search patterns or is a potential API call
+    return SEARCH_PATTERNS.some(pattern => pattern.test(url)) ||
+        url.includes('/api/') ||
+        url.includes('/v1/') ||
+        url.includes('/v2/');
+}
+async function captureRequest(request) {
+    const url = request.url();
+    if (!isInterestingUrl(url)) {
+        return;
+    }
+    const captured = {
+        url,
+        method: request.method(),
+        headers: request.headers(),
+        postData: request.postData() ?? undefined,
+        timestamp: new Date().toISOString(),
+        resourceType: request.resourceType(),
+    };
+    capturedNetworkData.requests.push(captured);
+    console.log(`\n📤 REQUEST: ${request.method()} ${url}`);
+    if (captured.postData) {
+        try {
+            const parsed = JSON.parse(captured.postData);
+            // Show full body for message sends (to see mention format)
+            const isMessageSend = url.includes('/messages') && request.method() === 'POST';
+            const limit = isMessageSend ? 10000 : 500;
+            console.log('   Body:', JSON.stringify(parsed, null, 2).substring(0, limit));
+        }
+        catch {
+            console.log('   Body:', captured.postData.substring(0, 200));
+        }
+    }
+}
+async function captureResponse(response) {
+    const url = response.url();
+    if (!isInterestingUrl(url)) {
+        return;
+    }
+    let body;
+    try {
+        const contentType = response.headers()['content-type'] || '';
+        if (contentType.includes('application/json') || contentType.includes('text/vtt') || contentType.includes('text/plain')) {
+            body = await response.text();
+        }
+    }
+    catch {
+        // Response body may not be available
+    }
+    const captured = {
+        url,
+        status: response.status(),
+        statusText: response.statusText(),
+        headers: response.headers(),
+        body,
+        timestamp: new Date().toISOString(),
+    };
+    capturedNetworkData.responses.push(captured);
+    console.log(`\n📥 RESPONSE: ${response.status()} ${url}`);
+    if (body) {
+        try {
+            const parsed = JSON.parse(body);
+            console.log('   Body preview:', JSON.stringify(parsed, null, 2).substring(0, 500));
+        }
+        catch {
+            console.log('   Body preview:', body.substring(0, 200));
+        }
+    }
+}
+async function saveFindings() {
+    // Deduplicate and summarise findings
+    const uniqueEndpoints = new Map();
+    for (const req of capturedNetworkData.requests) {
+        const key = `${req.method}:${new URL(req.url).pathname}`;
+        if (!uniqueEndpoints.has(key)) {
+            uniqueEndpoints.set(key, req);
+        }
+    }
+    const findings = {
+        discoveredAt: new Date().toISOString(),
+        uniqueEndpoints: Array.from(uniqueEndpoints.values()).map(req => ({
+            method: req.method,
+            url: req.url,
+            hasPostData: !!req.postData,
+            postDataSample: req.postData?.substring(0, 500),
+        })),
+        allRequests: capturedNetworkData.requests,
+        allResponses: capturedNetworkData.responses,
+    };
+    fs.writeFileSync(FINDINGS_PATH, JSON.stringify(findings, null, 2));
+    console.log(`\n💾 Findings saved to ${FINDINGS_PATH}`);
+}
+async function checkAuthentication(page) {
+    const url = page.url();
+    // Check if we're on a login page
+    if (url.includes('login.microsoftonline.com') ||
+        url.includes('login.live.com') ||
+        url.includes('login.microsoft.com')) {
+        return false;
+    }
+    // Check if we're on the Teams app
+    if (url.includes('teams.microsoft.com')) {
+        // Look for indicators that we're logged in
+        try {
+            // Wait briefly for the app to load
+            await page.waitForTimeout(2000);
+            // Check for common authenticated elements
+            const hasAppBar = await page.locator('[data-tid="app-bar"]').count() > 0;
+            const hasSearchBox = await page.locator('[data-tid="search-box"]').count() > 0 ||
+                await page.locator('input[placeholder*="Search"]').count() > 0;
+            return hasAppBar || hasSearchBox;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+async function waitForAuthentication(page) {
+    console.log('\n🔐 Please log in to Microsoft Teams in the browser window...');
+    console.log('   The script will continue once you are authenticated.\n');
+    // Poll for authentication
+    while (true) {
+        if (await checkAuthentication(page)) {
+            console.log('✅ Authentication detected!');
+            break;
+        }
+        await page.waitForTimeout(2000);
+    }
+}
+async function main() {
+    console.log('🔍 Teams Research Script');
+    console.log('========================\n');
+    console.log('This script will help discover how Teams web app works.\n');
+    // Ensure user data directory exists
+    if (!fs.existsSync(USER_DATA_DIR)) {
+        fs.mkdirSync(USER_DATA_DIR, { recursive: true });
+    }
+    let browser;
+    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 (uses encrypted store)
+        const existingState = readSessionState();
+        if (existingState) {
+            console.log('📂 Found existing session state, attempting to restore...');
+            context = await browser.newContext({
+                storageState: existingState,
+                viewport: { width: 1280, height: 800 },
+            });
+        }
+        else {
+            console.log('📂 No session state found, starting fresh...');
+            context = await browser.newContext({
+                viewport: { width: 1280, height: 800 },
+            });
+        }
+        const page = await context.newPage();
+        // Set up network interception
+        page.on('request', captureRequest);
+        page.on('response', captureResponse);
+        // Navigate to Teams
+        console.log('🌐 Navigating to Teams...');
+        await page.goto('https://teams.microsoft.com', { waitUntil: 'domcontentloaded' });
+        // Check if authentication is needed
+        const isAuthenticated = await checkAuthentication(page);
+        if (!isAuthenticated) {
+            await waitForAuthentication(page);
+            // Save session state after successful authentication
+            console.log('💾 Saving session state...');
+            const state = await context.storageState();
+            writeSessionState(state);
+            console.log('✅ Session state saved!');
+        }
+        else {
+            console.log('✅ Already authenticated!');
+        }
+        // Instructions for the user
+        console.log('\n' + '='.repeat(60));
+        console.log('🔬 RESEARCH MODE ACTIVE');
+        console.log('='.repeat(60));
+        console.log('\nThe browser is now monitoring network requests.');
+        console.log('Try the following to discover API endpoints:\n');
+        console.log('1. Use the search bar (Cmd/Ctrl+E or click the search icon)');
+        console.log('2. Search for some text');
+        console.log('3. Click on search results');
+        console.log('4. Navigate between chats and channels');
+        console.log('\nPress Ctrl+C in this terminal when done to save findings.');
+        console.log('='.repeat(60) + '\n');
+        // Keep the browser open until interrupted
+        await new Promise((resolve) => {
+            process.on('SIGINT', () => {
+                console.log('\n\n⏹️  Stopping research...');
+                resolve();
+            });
+        });
+        // 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);
+    }
+    finally {
+        try {
+            if (context)
+                await context.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}`);
+}
+main().catch(console.error);

package/dist/research/search-research.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Focused research script for Teams search API.
+ *
+ * Captures full request/response bodies for Substrate search endpoints
+ * to understand pagination, query format, and response structure.
+ *
+ * Usage:
+ *   npm run research:search
+ *
+ * Instructions:
+ *   1. Run this script
+ *   2. Perform a search in Teams
+ *   3. Click "Messages" tab or "See more results"
+ *   4. Scroll through results to trigger pagination
+ *   5. Press Ctrl+C to stop and save findings
+ */
+export {};