msteams-mcp 0.30.0 → 0.30.2

package/dist/research/search-research.js

@@ -0,0 +1,317 @@
+/**
+ * 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
+ */
+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 SESSION_STATE_PATH = path.join(PROJECT_ROOT, 'session-state.json');
+const SEARCH_FINDINGS_PATH = path.join(PROJECT_ROOT, 'search-api-findings.json');
+const captures = [];
+// Focus specifically on search-related endpoints
+function isSearchEndpoint(url) {
+    const searchPatterns = [
+        /substrate\.office\.com\/search/i,
+        /\/api\/v\d+\/query/i,
+        /\/api\/v\d+\/suggestions/i,
+        /\/search\//i,
+    ];
+    return searchPatterns.some(p => p.test(url));
+}
+async function captureSearchRequest(request) {
+    const url = request.url();
+    if (!isSearchEndpoint(url))
+        return;
+    const postData = request.postData();
+    let body;
+    if (postData) {
+        try {
+            body = JSON.parse(postData);
+        }
+        catch {
+            body = postData;
+        }
+    }
+    const capture = {
+        timestamp: new Date().toISOString(),
+        type: 'request',
+        url,
+        method: request.method(),
+        body,
+        headers: request.headers(),
+    };
+    captures.push(capture);
+    console.log('\n' + '━'.repeat(80));
+    console.log(`📤 SEARCH REQUEST: ${request.method()} ${url}`);
+    console.log('━'.repeat(80));
+    if (body) {
+        console.log('\n📋 Request Body:');
+        console.log(JSON.stringify(body, null, 2));
+    }
+    // Highlight pagination-related fields
+    if (body && typeof body === 'object') {
+        const bodyObj = body;
+        const paginationFields = ['Size', 'From', 'Skip', 'Top', 'Offset', 'PageSize', 'Page', 'MaxResults'];
+        const foundPagination = {};
+        function findPaginationFields(obj, prefix = '') {
+            if (!obj || typeof obj !== 'object')
+                return;
+            for (const [key, value] of Object.entries(obj)) {
+                const fullKey = prefix ? `${prefix}.${key}` : key;
+                if (paginationFields.some(p => key.toLowerCase().includes(p.toLowerCase()))) {
+                    foundPagination[fullKey] = value;
+                }
+                if (typeof value === 'object') {
+                    findPaginationFields(value, fullKey);
+                }
+            }
+        }
+        findPaginationFields(bodyObj);
+        if (Object.keys(foundPagination).length > 0) {
+            console.log('\n📊 Pagination Fields Found:');
+            console.log(JSON.stringify(foundPagination, null, 2));
+        }
+    }
+}
+async function captureSearchResponse(response) {
+    const url = response.url();
+    if (!isSearchEndpoint(url))
+        return;
+    let body;
+    try {
+        const contentType = response.headers()['content-type'] || '';
+        if (contentType.includes('application/json')) {
+            const text = await response.text();
+            body = JSON.parse(text);
+        }
+    }
+    catch {
+        // Response body may not be available
+    }
+    const capture = {
+        timestamp: new Date().toISOString(),
+        type: 'response',
+        url,
+        status: response.status(),
+        body,
+    };
+    captures.push(capture);
+    console.log('\n' + '━'.repeat(80));
+    console.log(`📥 SEARCH RESPONSE: ${response.status()} ${url}`);
+    console.log('━'.repeat(80));
+    if (body && typeof body === 'object') {
+        const bodyObj = body;
+        // Show structure summary
+        console.log('\n📋 Response Structure:');
+        const summarise = (obj, depth = 0) => {
+            if (depth > 2)
+                return '...';
+            if (Array.isArray(obj)) {
+                return `Array[${obj.length}]${obj.length > 0 ? ` of ${summarise(obj[0], depth + 1)}` : ''}`;
+            }
+            if (obj && typeof obj === 'object') {
+                const keys = Object.keys(obj);
+                if (keys.length > 8) {
+                    return `{${keys.slice(0, 5).join(', ')}, ... +${keys.length - 5} more}`;
+                }
+                return `{${keys.join(', ')}}`;
+            }
+            return typeof obj;
+        };
+        console.log(summarise(bodyObj));
+        // Show pagination-related response fields
+        const paginationResponseFields = ['Total', 'TotalCount', 'Count', 'HasMore', 'HasNext', 'NextLink', 'SkipToken', 'ContinuationToken'];
+        const foundPagination = {};
+        function findPaginationFields(obj, prefix = '') {
+            if (!obj || typeof obj !== 'object')
+                return;
+            for (const [key, value] of Object.entries(obj)) {
+                const fullKey = prefix ? `${prefix}.${key}` : key;
+                if (paginationResponseFields.some(p => key.toLowerCase().includes(p.toLowerCase()))) {
+                    foundPagination[fullKey] = value;
+                }
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    findPaginationFields(value, fullKey);
+                }
+            }
+        }
+        findPaginationFields(bodyObj);
+        if (Object.keys(foundPagination).length > 0) {
+            console.log('\n📊 Pagination Response Fields:');
+            console.log(JSON.stringify(foundPagination, null, 2));
+        }
+        // Show results count
+        const countArrays = (obj) => {
+            const results = [];
+            function traverse(o, path) {
+                if (Array.isArray(o) && o.length > 0) {
+                    results.push({ path: path || 'root', count: o.length });
+                }
+                if (o && typeof o === 'object' && !Array.isArray(o)) {
+                    for (const [key, value] of Object.entries(o)) {
+                        traverse(value, path ? `${path}.${key}` : key);
+                    }
+                }
+            }
+            traverse(obj, '');
+            return results;
+        };
+        const arrays = countArrays(bodyObj);
+        if (arrays.length > 0) {
+            console.log('\n📈 Result Counts:');
+            arrays.forEach(a => console.log(`   ${a.path}: ${a.count} items`));
+        }
+        // Show first result sample if available
+        const findFirstResult = (obj) => {
+            if (Array.isArray(obj) && obj.length > 0) {
+                const first = obj[0];
+                if (first && typeof first === 'object' && Object.keys(first).length > 2) {
+                    return first;
+                }
+            }
+            if (obj && typeof obj === 'object') {
+                for (const value of Object.values(obj)) {
+                    const found = findFirstResult(value);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        const firstResult = findFirstResult(bodyObj);
+        if (firstResult) {
+            console.log('\n📄 First Result Sample:');
+            console.log(JSON.stringify(firstResult, null, 2).substring(0, 1000));
+        }
+    }
+}
+async function checkAuthentication(page) {
+    const url = page.url();
+    if (url.includes('login.microsoftonline.com') ||
+        url.includes('login.live.com') ||
+        url.includes('login.microsoft.com')) {
+        return false;
+    }
+    if (url.includes('teams.microsoft.com')) {
+        try {
+            await page.waitForTimeout(2000);
+            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...');
+    while (true) {
+        if (await checkAuthentication(page)) {
+            console.log('✅ Authentication detected!');
+            break;
+        }
+        await page.waitForTimeout(2000);
+    }
+}
+async function saveFindings() {
+    const findings = {
+        capturedAt: new Date().toISOString(),
+        totalCaptures: captures.length,
+        requests: captures.filter(c => c.type === 'request'),
+        responses: captures.filter(c => c.type === 'response'),
+    };
+    fs.writeFileSync(SEARCH_FINDINGS_PATH, JSON.stringify(findings, null, 2));
+    console.log(`\n💾 Search findings saved to ${SEARCH_FINDINGS_PATH}`);
+}
+async function main() {
+    console.log('🔍 Teams Search API Research');
+    console.log('============================\n');
+    let browser;
+    let context;
+    try {
+        browser = await chromium.launch({ headless: false });
+        const hasSessionState = fs.existsSync(SESSION_STATE_PATH);
+        if (hasSessionState) {
+            console.log('📂 Restoring session state...');
+            context = await browser.newContext({
+                storageState: SESSION_STATE_PATH,
+                viewport: { width: 1400, height: 900 },
+            });
+        }
+        else {
+            console.log('📂 No session state found, starting fresh...');
+            context = await browser.newContext({
+                viewport: { width: 1400, height: 900 },
+            });
+        }
+        const page = await context.newPage();
+        // Set up network interception for search endpoints only
+        page.on('request', captureSearchRequest);
+        page.on('response', captureSearchResponse);
+        console.log('🌐 Navigating to Teams...');
+        await page.goto('https://teams.microsoft.com', { waitUntil: 'domcontentloaded' });
+        const isAuthenticated = await checkAuthentication(page);
+        if (!isAuthenticated) {
+            await waitForAuthentication(page);
+            await context.storageState({ path: SESSION_STATE_PATH });
+            console.log('✅ Session state saved!');
+        }
+        else {
+            console.log('✅ Already authenticated!');
+        }
+        console.log('\n' + '═'.repeat(60));
+        console.log('🔬 SEARCH RESEARCH MODE');
+        console.log('═'.repeat(60));
+        console.log('\nTo capture search API data:');
+        console.log('');
+        console.log('  1. Press Cmd/Ctrl+E to open search');
+        console.log('  2. Type a search query and press Enter');
+        console.log('  3. Click "Messages" tab to see message results');
+        console.log('  4. Click "See all results" if available');
+        console.log('  5. Scroll through results to trigger pagination');
+        console.log('');
+        console.log('Watch for 📊 Pagination Fields in the output!');
+        console.log('');
+        console.log('Press Ctrl+C when done to save findings.');
+        console.log('═'.repeat(60) + '\n');
+        await new Promise((resolve) => {
+            process.on('SIGINT', () => {
+                console.log('\n\n⏹️  Stopping research...');
+                resolve();
+            });
+        });
+        await context.storageState({ path: SESSION_STATE_PATH });
+        await saveFindings();
+    }
+    catch (error) {
+        console.error('❌ Error:', error);
+        throw error;
+    }
+    finally {
+        if (context)
+            await context.close();
+        if (browser)
+            await browser.close();
+    }
+    console.log('\n✅ Search research complete!');
+    console.log(`   Review findings in: ${SEARCH_FINDINGS_PATH}`);
+}
+main().catch(console.error);

package/dist/test/debug-search.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env npx tsx
+/**
+ * Debug script to inspect the Teams search page.
+ * Takes screenshots and dumps page structure for debugging selectors.
+ *
+ * Usage:
+ *   npm run debug:search
+ *   npm run debug:search -- "search query"
+ */
+export {};

package/dist/test/debug-search.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env npx tsx
+/**
+ * Debug script to inspect the Teams search page.
+ * Takes screenshots and dumps page structure for debugging selectors.
+ *
+ * Usage:
+ *   npm run debug:search
+ *   npm run debug:search -- "search query"
+ */
+import { createBrowserContext, closeBrowser } from '../browser/context.js';
+import { ensureAuthenticated } from '../browser/auth.js';
+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 DEBUG_DIR = path.join(PROJECT_ROOT, 'debug-output');
+async function main() {
+    const query = process.argv[2] ?? 'test';
+    console.log('🔍 Debug Search Script\n');
+    console.log(`Query: "${query}"`);
+    // Ensure debug output directory exists
+    if (!fs.existsSync(DEBUG_DIR)) {
+        fs.mkdirSync(DEBUG_DIR, { recursive: true });
+    }
+    const manager = await createBrowserContext({ headless: false });
+    try {
+        // Authenticate
+        console.log('\n1. Authenticating...');
+        await ensureAuthenticated(manager.page, manager.context);
+        // Take initial screenshot
+        console.log('\n2. Taking initial screenshot...');
+        await manager.page.screenshot({
+            path: path.join(DEBUG_DIR, '01-initial.png'),
+            fullPage: true
+        });
+        // Wait for page to stabilise
+        await manager.page.waitForTimeout(3000);
+        // Open search with keyboard shortcut
+        console.log('\n3. Opening search (Cmd+E)...');
+        const isMac = process.platform === 'darwin';
+        await manager.page.keyboard.press(isMac ? 'Meta+e' : 'Control+e');
+        await manager.page.waitForTimeout(2000);
+        await manager.page.screenshot({
+            path: path.join(DEBUG_DIR, '02-search-opened.png'),
+            fullPage: true
+        });
+        // Find and list all inputs
+        console.log('\n4. Scanning for input elements...');
+        const inputs = await manager.page.locator('input').all();
+        console.log(`   Found ${inputs.length} input elements:`);
+        for (let i = 0; i < inputs.length; i++) {
+            const input = inputs[i];
+            try {
+                const isVisible = await input.isVisible();
+                if (!isVisible)
+                    continue;
+                const placeholder = await input.getAttribute('placeholder') ?? '';
+                const ariaLabel = await input.getAttribute('aria-label') ?? '';
+                const dataTid = await input.getAttribute('data-tid') ?? '';
+                const type = await input.getAttribute('type') ?? '';
+                const id = await input.getAttribute('id') ?? '';
+                console.log(`   [${i}] visible=true, placeholder="${placeholder}", aria-label="${ariaLabel}", data-tid="${dataTid}", type="${type}", id="${id}"`);
+            }
+            catch {
+                // Skip
+            }
+        }
+        // Try to find and use search input
+        console.log('\n5. Looking for search input...');
+        const searchSelectors = [
+            'input[placeholder*="Search" i]',
+            'input[aria-label*="Search" i]',
+            '[data-tid*="search"] input',
+            'input[type="search"]',
+        ];
+        let searchInput = null;
+        for (const sel of searchSelectors) {
+            const loc = manager.page.locator(sel).first();
+            if (await loc.count() > 0 && await loc.isVisible()) {
+                console.log(`   Found with selector: ${sel}`);
+                searchInput = loc;
+                break;
+            }
+        }
+        if (searchInput) {
+            // Type the query
+            console.log('\n6. Typing query...');
+            await searchInput.fill(query);
+            await manager.page.waitForTimeout(500);
+            await manager.page.screenshot({
+                path: path.join(DEBUG_DIR, '03-query-typed.png'),
+                fullPage: true
+            });
+            // Submit
+            console.log('\n7. Submitting search (Enter)...');
+            await manager.page.keyboard.press('Enter');
+            await manager.page.waitForTimeout(5000);
+            await manager.page.screenshot({
+                path: path.join(DEBUG_DIR, '04-results.png'),
+                fullPage: true
+            });
+            // Scan for result elements
+            console.log('\n8. Scanning for result elements...');
+            const resultSelectors = [
+                '[data-tid*="search"]',
+                '[data-tid*="result"]',
+                '[role="listitem"]',
+                '[role="option"]',
+                '.search-result',
+                '[data-tid*="message"]',
+            ];
+            for (const sel of resultSelectors) {
+                const count = await manager.page.locator(sel).count();
+                if (count > 0) {
+                    console.log(`   ${sel}: ${count} elements`);
+                    // Get first element's text content preview
+                    const first = manager.page.locator(sel).first();
+                    const text = await first.textContent().catch(() => null);
+                    if (text) {
+                        console.log(`      Preview: "${text.substring(0, 80).replace(/\n/g, ' ')}..."`);
+                    }
+                }
+            }
+            // Dump page HTML structure (simplified)
+            console.log('\n9. Dumping main content structure...');
+            const mainContent = await manager.page.locator('main, [role="main"], #app, .app-container').first();
+            if (await mainContent.count() > 0) {
+                const html = await mainContent.innerHTML();
+                fs.writeFileSync(path.join(DEBUG_DIR, 'page-structure.html'), html.substring(0, 50000) // First 50KB
+                );
+                console.log('   Saved to debug-output/page-structure.html');
+            }
+        }
+        else {
+            console.log('   ❌ Could not find search input');
+        }
+        console.log('\n10. Keeping browser open for 30 seconds for manual inspection...');
+        console.log(`    Screenshots saved to: ${DEBUG_DIR}`);
+        await manager.page.waitForTimeout(30000);
+    }
+    finally {
+        await closeBrowser(manager, true);
+    }
+    console.log('\n✅ Debug session complete');
+}
+main().catch(console.error);

package/dist/test/mcp-harness.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env npx tsx
+/**
+ * MCP Protocol Test Harness
+ *
+ * Tests the MCP server by connecting a client through the actual MCP protocol,
+ * rather than calling underlying functions directly. This ensures the full
+ * protocol layer works correctly.
+ *
+ * Usage:
+ *   npm run test:mcp                              # List tools and check status
+ *   npm run test:mcp -- search "query"            # Search for messages (shortcut)
+ *   npm run test:mcp -- teams_search --query "q"  # Generic tool call
+ *   npm run test:mcp -- --json                    # Output as JSON
+ *
+ * Any unrecognised command is treated as a tool name. Use --key value for parameters.
+ */
+export {};