msteams-mcp 0.2.1

package/dist/server.js

@@ -0,0 +1,295 @@
+/**
+ * MCP Server implementation for Teams search.
+ * Exposes tools and resources for interacting with Microsoft Teams.
+ */
+import { createRequire } from 'module';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { createBrowserContext, closeBrowser } from './browser/context.js';
+import { ensureAuthenticated } from './browser/auth.js';
+// Auth modules
+import { hasSessionState, isSessionLikelyExpired, } from './auth/session-store.js';
+import { getSubstrateTokenStatus, extractMessageAuth, extractCsaToken, getUserProfile, } from './auth/token-extractor.js';
+// API modules
+import { getFavorites } from './api/csa-api.js';
+// Tool registry
+import { getToolDefinitions, invokeTool } from './tools/registry.js';
+// Types
+import { ErrorCode, createError } from './types/errors.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// MCP Server Class
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * MCP Server for Teams integration.
+ *
+ * Encapsulates all server state to allow multiple instances.
+ * Implements ITeamsServer interface for use by tool handlers.
+ */
+export class TeamsServer {
+    browserManager = null;
+    isInitialised = false;
+    // ───────────────────────────────────────────────────────────────────────────
+    // Response Formatting
+    // ───────────────────────────────────────────────────────────────────────────
+    /**
+     * Returns a standard MCP error response.
+     */
+    formatError(error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        error: error.message,
+                        errorCode: error.code,
+                        retryable: error.retryable,
+                        retryAfterMs: error.retryAfterMs,
+                        suggestions: error.suggestions,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    /**
+     * Returns a standard MCP success response.
+     */
+    formatSuccess(data) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ success: true, ...data }, null, 2),
+                },
+            ],
+        };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Browser State Management (exposed for tool handlers)
+    // ───────────────────────────────────────────────────────────────────────────
+    /**
+     * Gets the current browser manager.
+     */
+    getBrowserManager() {
+        return this.browserManager;
+    }
+    /**
+     * Sets the browser manager.
+     */
+    setBrowserManager(manager) {
+        this.browserManager = manager;
+    }
+    /**
+     * Resets browser state.
+     */
+    resetBrowserState() {
+        this.browserManager = null;
+        this.isInitialised = false;
+    }
+    /**
+     * Marks the server as initialised.
+     */
+    markInitialised() {
+        this.isInitialised = true;
+    }
+    /**
+     * Checks if the server is initialised.
+     */
+    isInitialisedState() {
+        return this.isInitialised;
+    }
+    /**
+     * Ensures the browser is running and authenticated.
+     */
+    async ensureBrowser(headless = true) {
+        if (this.browserManager && this.isInitialised) {
+            return this.browserManager;
+        }
+        // Close existing browser if any
+        if (this.browserManager) {
+            try {
+                await closeBrowser(this.browserManager, true);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        this.browserManager = await createBrowserContext({ headless });
+        await ensureAuthenticated(this.browserManager.page, this.browserManager.context, (msg) => console.error(`[auth] ${msg}`));
+        this.isInitialised = true;
+        return this.browserManager;
+    }
+    /**
+     * Cleans up browser resources.
+     */
+    async cleanup() {
+        if (this.browserManager) {
+            await closeBrowser(this.browserManager, true);
+            this.browserManager = null;
+            this.isInitialised = false;
+        }
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Server Creation
+    // ───────────────────────────────────────────────────────────────────────────
+    /**
+     * Creates and configures the MCP server.
+     */
+    async createServer() {
+        const server = new Server({
+            name: 'teams-mcp',
+            version: pkg.version,
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+            },
+        });
+        // Handle resource listing
+        server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            return {
+                resources: [
+                    {
+                        uri: 'teams://me/profile',
+                        name: 'Current User Profile',
+                        description: 'The authenticated user\'s Teams profile including email and display name',
+                        mimeType: 'application/json',
+                    },
+                    {
+                        uri: 'teams://me/favorites',
+                        name: 'Pinned Conversations',
+                        description: 'The user\'s favourite/pinned Teams conversations',
+                        mimeType: 'application/json',
+                    },
+                    {
+                        uri: 'teams://status',
+                        name: 'Authentication Status',
+                        description: 'Current authentication status for all Teams APIs',
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        });
+        // Handle resource reading
+        server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            const { uri } = request.params;
+            switch (uri) {
+                case 'teams://me/profile': {
+                    const profile = getUserProfile();
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: JSON.stringify(profile ?? { error: 'No valid session' }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'teams://me/favorites': {
+                    const result = await getFavorites();
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: JSON.stringify(result.ok ? result.value.favorites : { error: result.error.message }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'teams://status': {
+                    const tokenStatus = getSubstrateTokenStatus();
+                    const messageAuth = extractMessageAuth();
+                    const csaToken = extractCsaToken();
+                    const status = {
+                        directApi: {
+                            available: tokenStatus.hasToken,
+                            expiresAt: tokenStatus.expiresAt,
+                            minutesRemaining: tokenStatus.minutesRemaining,
+                        },
+                        messaging: {
+                            available: messageAuth !== null,
+                        },
+                        favorites: {
+                            available: messageAuth !== null && csaToken !== null,
+                        },
+                        session: {
+                            exists: hasSessionState(),
+                            likelyExpired: isSessionLikelyExpired(),
+                        },
+                    };
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: 'application/json',
+                                text: JSON.stringify(status, null, 2),
+                            },
+                        ],
+                    };
+                }
+                default:
+                    throw new Error(`Unknown resource: ${uri}`);
+            }
+        });
+        // Handle tool listing
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return { tools: getToolDefinitions() };
+        });
+        // Handle tool calls
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                const ctx = { server: this };
+                const result = await invokeTool(name, args, ctx);
+                if (result.success) {
+                    return this.formatSuccess(result.data);
+                }
+                else {
+                    return this.formatError(result.error);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return this.formatError(createError(ErrorCode.UNKNOWN, message, { retryable: false }));
+            }
+        });
+        // Cleanup on server close
+        server.onclose = async () => {
+            await this.cleanup();
+        };
+        return server;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Exports
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Creates and runs the MCP server.
+ * Exported for backward compatibility.
+ */
+export async function createServer() {
+    const teamsServer = new TeamsServer();
+    return teamsServer.createServer();
+}
+/**
+ * Runs the server with stdio transport.
+ */
+export async function runServer() {
+    const teamsServer = new TeamsServer();
+    const server = await teamsServer.createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Handle shutdown signals
+    const shutdown = async () => {
+        await teamsServer.cleanup();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

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 {};