msteams-mcp 0.2.0

package/dist/test/cli.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env npx tsx
+/**
+ * CLI tool to interact with Teams MCP functionality directly.
+ * Useful for testing individual operations.
+ *
+ * Usage:
+ *   npm run cli -- status
+ *   npm run cli -- search "your query"
+ *   npm run cli -- login
+ *   npm run cli -- login --force
+ */
+import { createBrowserContext, closeBrowser } from '../browser/context.js';
+import { ensureAuthenticated, forceNewLogin } from '../browser/auth.js';
+import { hasSessionState, getSessionAge, clearSessionState, } from '../auth/session-store.js';
+import { hasValidSubstrateToken, getSubstrateTokenStatus, extractMessageAuth, getUserProfile, clearTokenCache, } from '../auth/token-extractor.js';
+import { searchMessages } from '../api/substrate-api.js';
+import { sendMessage, sendNoteToSelf } from '../api/chatsvc-api.js';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const command = (args[0] ?? 'help');
+    const flags = new Set();
+    const options = new Map();
+    const remainingArgs = [];
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--') && arg.includes('=')) {
+            const [key, value] = arg.slice(2).split('=', 2);
+            options.set(key, value);
+        }
+        else if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith('-')) {
+                if (/^\d+$/.test(next)) {
+                    options.set(key, next);
+                    i++;
+                }
+                else {
+                    flags.add(key);
+                }
+            }
+            else {
+                flags.add(key);
+            }
+        }
+        else if (arg.startsWith('-')) {
+            flags.add(arg.slice(1));
+        }
+        else {
+            remainingArgs.push(arg);
+        }
+    }
+    return { command, args: remainingArgs, flags, options };
+}
+function printHelp() {
+    console.log(`
+Teams MCP CLI
+
+Commands:
+  status              Check session and authentication status
+  search <query>      Search Teams for messages (requires valid token)
+  send <message>      Send a message to yourself (notes)
+  send --to <id>      Send a message to a specific conversation
+  me                  Get current user profile (email, name, Teams ID)
+  login               Log in to Teams (opens browser)
+  login --force       Force new login (clears existing session)
+  help                Show this help message
+
+Options:
+  --json              Output results as JSON
+
+Pagination Options (for search):
+  --from <n>          Starting offset (default: 0, for page 2 use --from 25)
+  --size <n>          Page size (default: 25)
+  --maxResults <n>    Maximum results to return (default: 25)
+
+Send Options:
+  --to <conversationId>   Send to a specific conversation (default: 48:notes = self)
+
+Examples:
+  npm run cli -- status
+  npm run cli -- search "meeting notes"
+  npm run cli -- search "project update" --json
+  npm run cli -- search "query" --from 25
+  npm run cli -- send "Test message to myself"
+  npm run cli -- login --force
+`);
+}
+async function commandStatus(flags) {
+    const hasSession = hasSessionState();
+    const sessionAge = getSessionAge();
+    const tokenStatus = getSubstrateTokenStatus();
+    const status = {
+        directApi: {
+            available: tokenStatus.hasToken,
+            expiresAt: tokenStatus.expiresAt,
+            minutesRemaining: tokenStatus.minutesRemaining,
+        },
+        session: {
+            exists: hasSession,
+            ageHours: sessionAge !== null ? Math.round(sessionAge * 10) / 10 : null,
+            likelyExpired: sessionAge !== null ? sessionAge > 12 : null,
+        },
+    };
+    if (flags.has('json')) {
+        console.log(JSON.stringify(status, null, 2));
+    }
+    else {
+        console.log('\n📊 Status\n');
+        if (status.directApi.available) {
+            console.log(`Direct API: ✅ Available (${status.directApi.minutesRemaining} min remaining)`);
+        }
+        else {
+            console.log('Direct API: ❌ No valid token (browser login required)');
+        }
+        console.log(`Session exists: ${status.session.exists ? '✅ Yes' : '❌ No'}`);
+        if (status.session.ageHours !== null) {
+            console.log(`Session age: ${status.session.ageHours} hours`);
+            if (status.session.likelyExpired) {
+                console.log('⚠️  Session may be expired');
+            }
+        }
+    }
+}
+async function commandSearch(query, flags, options) {
+    if (!query) {
+        console.error('❌ Error: Search query required');
+        console.error('   Usage: npm run cli -- search "your query"');
+        process.exit(1);
+    }
+    const asJson = flags.has('json');
+    const from = options.has('from') ? parseInt(options.get('from'), 10) : 0;
+    const size = options.has('size') ? parseInt(options.get('size'), 10) : 25;
+    const maxResults = options.has('maxResults') ? parseInt(options.get('maxResults'), 10) : 25;
+    if (!hasValidSubstrateToken()) {
+        if (asJson) {
+            console.log(JSON.stringify({ success: false, error: 'No valid token. Please run: npm run cli -- login' }, null, 2));
+        }
+        else {
+            console.error('❌ No valid token. Please run: npm run cli -- login');
+        }
+        process.exit(1);
+    }
+    if (!asJson) {
+        console.log(`\n🔍 Searching for: "${query}"`);
+        if (from > 0) {
+            console.log(`   Offset: ${from}, Size: ${size}`);
+        }
+    }
+    const result = await searchMessages(query, { from, size, maxResults });
+    if (!result.ok) {
+        if (asJson) {
+            console.log(JSON.stringify({ success: false, error: result.error.message }, null, 2));
+        }
+        else {
+            console.error(`❌ Search failed: ${result.error.message}`);
+        }
+        process.exit(1);
+    }
+    if (asJson) {
+        console.log(JSON.stringify({
+            query,
+            count: result.value.results.length,
+            pagination: {
+                from: result.value.pagination.from,
+                size: result.value.pagination.size,
+                returned: result.value.pagination.returned,
+                total: result.value.pagination.total,
+                hasMore: result.value.pagination.hasMore,
+                nextFrom: result.value.pagination.hasMore
+                    ? result.value.pagination.from + result.value.pagination.returned
+                    : undefined,
+            },
+            results: result.value.results,
+        }, null, 2));
+    }
+    else {
+        printResults(result.value.results, result.value.pagination);
+    }
+}
+function printResults(results, pagination) {
+    console.log(`\n📋 Found ${results.length} results`);
+    if (pagination.total !== undefined) {
+        console.log(`   Total available: ${pagination.total}`);
+    }
+    if (pagination.hasMore) {
+        console.log(`   More results available (use --from ${pagination.from + pagination.returned})`);
+    }
+    console.log();
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        console.log(`${pagination.from + i + 1}. ${r.content.substring(0, 100).replace(/\n/g, ' ')}${r.content.length > 100 ? '...' : ''}`);
+        if (r.sender)
+            console.log(`   From: ${r.sender}`);
+        if (r.timestamp)
+            console.log(`   Time: ${r.timestamp}`);
+        console.log();
+    }
+}
+async function commandSend(message, flags, options) {
+    if (!message) {
+        console.error('❌ Error: Message content required');
+        console.error('   Usage: npm run cli -- send "your message"');
+        process.exit(1);
+    }
+    const asJson = flags.has('json');
+    const conversationId = options.get('to') || '48:notes';
+    const auth = extractMessageAuth();
+    if (!auth) {
+        console.error('❌ No valid authentication. Please run: npm run cli -- login');
+        process.exit(1);
+    }
+    if (!asJson) {
+        if (conversationId === '48:notes') {
+            console.log(`\n📝 Sending note to yourself...`);
+        }
+        else {
+            console.log(`\n📤 Sending message to: ${conversationId}`);
+        }
+        console.log(`   Content: "${message.substring(0, 50)}${message.length > 50 ? '...' : ''}"`);
+    }
+    const result = conversationId === '48:notes'
+        ? await sendNoteToSelf(message)
+        : await sendMessage(conversationId, message);
+    if (asJson) {
+        console.log(JSON.stringify(result.ok
+            ? { success: true, ...result.value }
+            : { success: false, error: result.error.message }, null, 2));
+    }
+    else {
+        if (result.ok) {
+            console.log('\n✅ Message sent successfully!');
+            console.log(`   Message ID: ${result.value.messageId}`);
+            if (result.value.timestamp) {
+                console.log(`   Timestamp: ${new Date(result.value.timestamp).toISOString()}`);
+            }
+        }
+        else {
+            console.error(`\n❌ Failed to send message: ${result.error.message}`);
+            process.exit(1);
+        }
+    }
+}
+async function commandMe(flags) {
+    const asJson = flags.has('json');
+    const profile = getUserProfile();
+    if (!profile) {
+        if (asJson) {
+            console.log(JSON.stringify({ success: false, error: 'No valid session' }, null, 2));
+        }
+        else {
+            console.error('❌ No valid session. Please run: npm run cli -- login');
+        }
+        process.exit(1);
+    }
+    if (asJson) {
+        console.log(JSON.stringify({ success: true, profile }, null, 2));
+    }
+    else {
+        console.log('\n👤 Current User\n');
+        console.log(`   Name: ${profile.displayName}`);
+        console.log(`   Email: ${profile.email}`);
+        console.log(`   ID: ${profile.id}`);
+        console.log(`   MRI: ${profile.mri}`);
+        if (profile.tenantId) {
+            console.log(`   Tenant: ${profile.tenantId}`);
+        }
+    }
+}
+async function commandLogin(flags) {
+    const force = flags.has('force');
+    if (force) {
+        console.log('🔄 Forcing new login (clearing existing session)...');
+        clearSessionState();
+        clearTokenCache();
+    }
+    else {
+        console.log('🔐 Starting login flow...');
+    }
+    let manager = null;
+    try {
+        manager = await createBrowserContext({ headless: false });
+        if (force) {
+            await forceNewLogin(manager.page, manager.context, (msg) => console.log(`   ${msg}`));
+        }
+        else {
+            await ensureAuthenticated(manager.page, manager.context, (msg) => console.log(`   ${msg}`));
+        }
+        console.log('\n✅ Login successful! Session has been saved.');
+        console.log('   You can now run searches in headless mode.');
+    }
+    finally {
+        if (manager) {
+            await closeBrowser(manager, true);
+        }
+    }
+}
+async function main() {
+    const { command, args, flags, options } = parseArgs();
+    try {
+        switch (command) {
+            case 'status':
+                await commandStatus(flags);
+                break;
+            case 'search':
+                await commandSearch(args.join(' '), flags, options);
+                break;
+            case 'send':
+                await commandSend(args.join(' '), flags, options);
+                break;
+            case 'me':
+                await commandMe(flags);
+                break;
+            case 'login':
+                await commandLogin(flags);
+                break;
+            case 'help':
+            default:
+                printHelp();
+                break;
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+main();

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/manual-test.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env npx tsx
+/**
+ * Manual testing script for Teams MCP functionality.
+ * Runs through the core features to verify they work.
+ *
+ * Usage:
+ *   npm run test:manual
+ *   npm run test:manual -- --search "your query"
+ *   npm run test:manual -- --headless
+ */
+export {};

package/dist/test/manual-test.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env npx tsx
+/**
+ * Manual testing script for Teams MCP functionality.
+ * Runs through the core features to verify they work.
+ *
+ * Usage:
+ *   npm run test:manual
+ *   npm run test:manual -- --search "your query"
+ *   npm run test:manual -- --headless
+ */
+import { createBrowserContext, closeBrowser } from '../browser/context.js';
+import { getAuthStatus, ensureAuthenticated } from '../browser/auth.js';
+import { searchTeams } from '../teams/search.js';
+import { hasSessionState, getSessionAge } from '../auth/session-store.js';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        headless: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--headless') {
+            options.headless = true;
+        }
+        else if (args[i] === '--search' && args[i + 1]) {
+            options.searchQuery = args[i + 1];
+            i++;
+        }
+    }
+    return options;
+}
+function log(message, indent = 0) {
+    const prefix = '  '.repeat(indent);
+    console.log(`${prefix}${message}`);
+}
+function logSection(title) {
+    console.log('\n' + '─'.repeat(50));
+    console.log(`  ${title}`);
+    console.log('─'.repeat(50));
+}
+async function testSessionState() {
+    logSection('Session State');
+    const hasSession = hasSessionState();
+    const sessionAge = getSessionAge();
+    log(`Session exists: ${hasSession ? '✅ Yes' : '❌ No'}`);
+    if (sessionAge !== null) {
+        const ageHours = sessionAge.toFixed(1);
+        const isOld = sessionAge > 12;
+        log(`Session age: ${ageHours} hours ${isOld ? '⚠️ (may be expired)' : '✅'}`);
+    }
+    return hasSession;
+}
+async function testBrowserContext(headless) {
+    logSection('Browser Context');
+    log(`Creating browser (headless: ${headless})...`);
+    try {
+        const manager = await createBrowserContext({ headless });
+        log(`Browser launched: ✅`);
+        log(`New session: ${manager.isNewSession ? 'Yes (will need login)' : 'No (restored from saved)'}`);
+        return manager;
+    }
+    catch (error) {
+        log(`Browser launch failed: ❌`);
+        log(`Error: ${error instanceof Error ? error.message : String(error)}`, 1);
+        return null;
+    }
+}
+async function testAuthentication(manager) {
+    logSection('Authentication');
+    log('Checking authentication status...');
+    try {
+        await ensureAuthenticated(manager.page, manager.context, (msg) => log(`  ${msg}`));
+        const status = await getAuthStatus(manager.page);
+        log(`Authenticated: ${status.isAuthenticated ? '✅ Yes' : '❌ No'}`);
+        log(`Current URL: ${status.currentUrl}`, 1);
+        return status.isAuthenticated;
+    }
+    catch (error) {
+        log(`Authentication failed: ❌`);
+        log(`Error: ${error instanceof Error ? error.message : String(error)}`, 1);
+        return false;
+    }
+}
+async function testSearch(manager, query) {
+    logSection('Search');
+    log(`Searching for: "${query}"...`);
+    try {
+        const results = await searchTeams(manager.page, query, {
+            maxResults: 10,
+            waitMs: 8000,
+        });
+        log(`Results found: ${results.length}`);
+        if (results.length > 0) {
+            log('Sample results:', 1);
+            for (const result of results.slice(0, 3)) {
+                const preview = result.content.substring(0, 80).replace(/\n/g, ' ');
+                log(`• ${preview}${result.content.length > 80 ? '...' : ''}`, 2);
+                if (result.sender) {
+                    log(`  From: ${result.sender}`, 2);
+                }
+            }
+        }
+        return results.length > 0;
+    }
+    catch (error) {
+        log(`Search failed: ❌`);
+        log(`Error: ${error instanceof Error ? error.message : String(error)}`, 1);
+        return false;
+    }
+}
+async function runTests() {
+    console.log('\n🧪 Teams MCP Manual Test');
+    console.log('========================\n');
+    const options = parseArgs();
+    if (options.headless) {
+        log('Running in headless mode');
+    }
+    else {
+        log('Running with visible browser (use --headless to run headless)');
+    }
+    // Test 1: Session state
+    const hasSession = await testSessionState();
+    if (!hasSession && options.headless) {
+        log('\n⚠️  No session found. Cannot run headless without a saved session.');
+        log('   Run without --headless first to log in, or run: npm run research');
+        process.exit(1);
+    }
+    // Test 2: Browser context
+    const manager = await testBrowserContext(options.headless);
+    if (!manager) {
+        process.exit(1);
+    }
+    try {
+        // Test 3: Authentication
+        const isAuthenticated = await testAuthentication(manager);
+        if (!isAuthenticated) {
+            log('\n⚠️  Not authenticated. Please log in manually in the browser window.');
+            log('   Waiting for authentication...');
+            // The ensureAuthenticated call above should have handled this
+        }
+        // Test 4: Search (if query provided or use default)
+        const searchQuery = options.searchQuery ?? 'test';
+        await testSearch(manager, searchQuery);
+        // Summary
+        logSection('Summary');
+        log('Tests completed. Review results above.');
+        if (!options.headless) {
+            log('\nBrowser will remain open for 10 seconds for inspection...');
+            await manager.page.waitForTimeout(10000);
+        }
+    }
+    finally {
+        log('\nClosing browser...');
+        await closeBrowser(manager, true);
+        log('Done.');
+    }
+}
+runTests().catch((error) => {
+    console.error('\n❌ Test failed with error:', error);
+    process.exit(1);
+});

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