msteams-mcp 0.25.0 → 0.26.0

package/dist/browser/chrome-cookie-import.js

@@ -1,294 +0,0 @@
-/**
- * Import Microsoft SSO cookies from the user's Chrome profile into a Playwright context.
- *
- * When the Teams MCP server needs to open a visible browser for login,
- * the Playwright profile is isolated from the user's real Chrome — so Microsoft
- * can't recognise the user via SSO. This module copies the relevant Microsoft
- * cookies from the user's actual Chrome work profile, enabling silent SSO in
- * the Playwright browser and eliminating the need to re-type credentials.
- *
- * macOS only (Chrome cookies are encrypted with a Keychain-backed key).
- * Fails gracefully on other platforms or when Chrome isn't available.
- *
- * Configuration:
- *   TEAMS_MCP_CHROME_PROFILE env var — Chrome profile directory name
- *   (e.g. "Profile 1"). If unset, auto-detects from Chrome's Local State.
- */
-import * as crypto from 'crypto';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import * as log from '../utils/logger.js';
-// Microsoft domains whose cookies enable SSO
-const MICROSOFT_DOMAINS = [
-    '%microsoftonline%',
-    '%login.live.com%',
-    '%login.microsoft.com%',
-    '%microsoft.com%',
-    '%office.com%',
-    '%office365.com%',
-];
-const CHROME_DATA_DIR = path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome');
-// ─────────────────────────────────────────────────────────────────────────────
-// Chrome Profile Detection
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Lists Chrome profiles from the Local State file.
- */
-function listChromeProfiles() {
-    const localStatePath = path.join(CHROME_DATA_DIR, 'Local State');
-    if (!fs.existsSync(localStatePath))
-        return [];
-    try {
-        const localState = JSON.parse(fs.readFileSync(localStatePath, 'utf8'));
-        const infoCache = localState?.profile?.info_cache;
-        if (!infoCache || typeof infoCache !== 'object')
-            return [];
-        return Object.entries(infoCache).map(([dirName, info]) => {
-            const i = info;
-            return {
-                dirName,
-                name: String(i.name ?? ''),
-                gaiaName: String(i.gaia_name ?? ''),
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Selects the Chrome profile to import cookies from.
- *
- * Priority:
- * 1. TEAMS_MCP_CHROME_PROFILE env var (exact dir name like "Profile 1")
- * 2. Auto-detect: first profile whose name looks like a work/corporate account
- * 3. null if no suitable profile found
- */
-function selectChromeProfile() {
-    const profiles = listChromeProfiles();
-    if (profiles.length === 0)
-        return null;
-    // Priority 1: explicit env var
-    const envProfile = process.env.TEAMS_MCP_CHROME_PROFILE;
-    if (envProfile) {
-        const match = profiles.find(p => p.dirName === envProfile);
-        if (match)
-            return match;
-        log.warn('cookie-import', `TEAMS_MCP_CHROME_PROFILE="${envProfile}" not found. Available: ${profiles.map(p => `${p.dirName} (${p.name})`).join(', ')}`);
-        return null;
-    }
-    // Priority 2: auto-detect work profile (contains a domain-like name)
-    const workProfile = profiles.find(p => /\.[a-z]{2,}$/i.test(p.name) || // name contains a domain (e.g. "corp.example.com")
-        p.name.toLowerCase().includes('work') ||
-        p.name.toLowerCase().includes('corp'));
-    if (workProfile)
-        return workProfile;
-    // Skip auto-import if we can't identify a work profile
-    return null;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Cookie Decryption (macOS)
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Cached AES key derived from the Chrome Safe Storage Keychain password.
- * Cached for the lifetime of the MCP server process so the Keychain
- * prompt only appears once (on first cookie import after server start).
- *
- * Tip: click "Always Allow" on the macOS Keychain dialog to permanently
- * authorize this process — then no prompt appears at all.
- */
-let cachedKey = null;
-/**
- * Gets (or retrieves from cache) the AES key for Chrome cookie decryption.
- * Accesses the macOS Keychain only on first call, caches for process lifetime.
- */
-function getDecryptionKey() {
-    if (cachedKey)
-        return cachedKey;
-    let password;
-    try {
-        password = execSync('security find-generic-password -s "Chrome Safe Storage" -w', { encoding: 'utf8', timeout: 5000 }).trim();
-    }
-    catch {
-        return null;
-    }
-    cachedKey = crypto.pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1');
-    return cachedKey;
-}
-/**
- * Decrypts a Chrome cookie value.
- * Chrome macOS cookies are prefixed with 'v10' followed by AES-128-CBC ciphertext.
- */
-function decryptCookieValue(hexValue, key) {
-    try {
-        const encrypted = Buffer.from(hexValue, 'hex');
-        // v10 prefix check (0x76 0x31 0x30)
-        if (encrypted.length < 4 || encrypted[0] !== 0x76 || encrypted[1] !== 0x31 || encrypted[2] !== 0x30) {
-            // Not encrypted or unknown format — try as plain text
-            return encrypted.toString('utf8');
-        }
-        const ciphertext = encrypted.subarray(3);
-        const iv = Buffer.alloc(16, 0x20); // 16 bytes of space (0x20)
-        const decipher = crypto.createDecipheriv('aes-128-cbc', key, iv);
-        decipher.setAutoPadding(true);
-        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-        return decrypted.toString('utf8');
-    }
-    catch {
-        return null;
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Cookie Reading (via sqlite3 CLI)
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Reads Microsoft-related cookies from a Chrome profile's Cookies database.
- * Copies the DB to a temp file to avoid locking conflicts with running Chrome.
- */
-function readChromeCookies(profileDir) {
-    const cookiesDb = path.join(CHROME_DATA_DIR, profileDir, 'Cookies');
-    if (!fs.existsSync(cookiesDb))
-        return [];
-    // Copy to temp to avoid lock conflicts with running Chrome
-    const tmpDb = path.join(os.tmpdir(), `teams-mcp-cookies-${Date.now()}.db`);
-    try {
-        fs.copyFileSync(cookiesDb, tmpDb);
-        // Also copy WAL/SHM if they exist (needed for consistent reads)
-        for (const ext of ['-wal', '-shm']) {
-            const src = cookiesDb + ext;
-            if (fs.existsSync(src)) {
-                fs.copyFileSync(src, tmpDb + ext);
-            }
-        }
-        const whereClause = MICROSOFT_DOMAINS.map(d => `host_key LIKE '${d}'`).join(' OR ');
-        const sql = `SELECT host_key, name, hex(encrypted_value) as ev, path, expires_utc, is_secure, is_httponly, samesite FROM cookies WHERE (${whereClause}) AND expires_utc > 0`;
-        const output = execSync(`sqlite3 -separator '|||' "${tmpDb}" "${sql}"`, { encoding: 'utf8', timeout: 10000, maxBuffer: 1024 * 1024 });
-        return output
-            .trim()
-            .split('\n')
-            .filter(line => line.includes('|||'))
-            .map(line => {
-            const [host_key, name, encrypted_value_hex, cookiePath, expires_utc, is_secure, is_httponly, samesite] = line.split('|||');
-            return {
-                host_key,
-                name,
-                encrypted_value_hex,
-                path: cookiePath,
-                expires_utc: parseInt(expires_utc, 10),
-                is_secure: parseInt(is_secure, 10),
-                is_httponly: parseInt(is_httponly, 10),
-                samesite: parseInt(samesite, 10),
-            };
-        });
-    }
-    catch (err) {
-        log.warn('cookie-import', `Failed to read Chrome cookies: ${err instanceof Error ? err.message : String(err)}`);
-        return [];
-    }
-    finally {
-        // Clean up temp files
-        for (const f of [tmpDb, tmpDb + '-wal', tmpDb + '-shm']) {
-            try {
-                fs.unlinkSync(f);
-            }
-            catch { /* ignore */ }
-        }
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Cookie Conversion
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Converts Chrome epoch (microseconds since 1601-01-01) to Unix epoch (seconds since 1970-01-01).
- */
-function chromeEpochToUnix(chromeTimestamp) {
-    // Chrome epoch starts 11644473600 seconds before Unix epoch
-    return Math.floor(chromeTimestamp / 1_000_000) - 11644473600;
-}
-/**
- * Maps Chrome's samesite integer to Playwright's string value.
- */
-function chromeSameSiteToPlaywright(samesite) {
-    switch (samesite) {
-        case 2: return 'Strict';
-        case 1: return 'Lax';
-        default: return 'None';
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Public API
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Imports Microsoft SSO cookies from the user's Chrome profile into a Playwright context.
- *
- * This enables SSO in the Playwright browser so the user doesn't have to type
- * credentials when Microsoft redirects to the login page.
- *
- * Fails silently — cookie import is best-effort. If it doesn't work,
- * the user just has to log in manually as before.
- */
-export async function importMicrosoftCookies(context) {
-    // Only supported on macOS
-    if (process.platform !== 'darwin') {
-        log.debug('cookie-import', 'Skipping cookie import (not macOS)');
-        return;
-    }
-    // Check if Chrome is installed
-    if (!fs.existsSync(CHROME_DATA_DIR)) {
-        log.debug('cookie-import', 'Skipping cookie import (Chrome not found)');
-        return;
-    }
-    const profile = selectChromeProfile();
-    if (!profile) {
-        log.debug('cookie-import', 'No Chrome work profile found. Set TEAMS_MCP_CHROME_PROFILE env var.');
-        return;
-    }
-    log.info('cookie-import', `Importing Microsoft cookies from Chrome profile: ${profile.dirName} (${profile.name})`);
-    // Get decryption key (cached after first access — only one Keychain prompt per server lifetime)
-    const key = getDecryptionKey();
-    if (!key) {
-        log.warn('cookie-import', 'Could not get Chrome Safe Storage password from Keychain. ' +
-            'To fix, run: security set-generic-password-partition-list -S "apple-tool:,apple:" ' +
-            '-a "Chrome" -s "Chrome Safe Storage" ~/Library/Keychains/login.keychain-db');
-        return;
-    }
-    // Read and decrypt cookies
-    const rawCookies = readChromeCookies(profile.dirName);
-    if (rawCookies.length === 0) {
-        log.info('cookie-import', 'No Microsoft cookies found in Chrome profile');
-        return;
-    }
-    const playwrightCookies = [];
-    for (const raw of rawCookies) {
-        const value = decryptCookieValue(raw.encrypted_value_hex, key);
-        if (!value)
-            continue;
-        const expires = chromeEpochToUnix(raw.expires_utc);
-        // Skip expired cookies
-        if (expires <= Math.floor(Date.now() / 1000))
-            continue;
-        playwrightCookies.push({
-            name: raw.name,
-            value,
-            domain: raw.host_key,
-            path: raw.path,
-            expires,
-            httpOnly: raw.is_httponly === 1,
-            secure: raw.is_secure === 1,
-            sameSite: chromeSameSiteToPlaywright(raw.samesite),
-        });
-    }
-    if (playwrightCookies.length === 0) {
-        log.info('cookie-import', 'No valid Microsoft cookies to import');
-        return;
-    }
-    try {
-        await context.addCookies(playwrightCookies);
-        log.info('cookie-import', `Imported ${playwrightCookies.length} Microsoft cookies from Chrome "${profile.name}" profile`);
-    }
-    catch (err) {
-        log.warn('cookie-import', `Failed to inject cookies: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}

package/dist/browser/chrome-cookie-import.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/browser/chrome-cookie-import.test.js

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as crypto from 'crypto';
-/**
- * Tests for the cookie import logic.
- *
- * The public importMicrosoftCookies() function depends on filesystem, Keychain,
- * and sqlite3 — so we test the pure cryptographic and conversion logic directly.
- */
-describe('chrome-cookie-import logic', () => {
-    describe('cookie decryption (v10 AES-128-CBC)', () => {
-        // Replicate Chrome macOS encryption: PBKDF2-SHA1, salt='saltysalt', 1003 iters
-        const password = 'test-password';
-        const key = crypto.pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1');
-        const iv = Buffer.alloc(16, 0x20); // 16 spaces
-        function encrypt(plaintext) {
-            const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
-            const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
-            return Buffer.concat([Buffer.from('v10'), encrypted]).toString('hex');
-        }
-        function decrypt(hexValue) {
-            const buf = Buffer.from(hexValue, 'hex');
-            if (buf.length < 4 || buf[0] !== 0x76 || buf[1] !== 0x31 || buf[2] !== 0x30) {
-                return buf.toString('utf8');
-            }
-            try {
-                const decipher = crypto.createDecipheriv('aes-128-cbc', key, iv);
-                decipher.setAutoPadding(true);
-                return Buffer.concat([decipher.update(buf.subarray(3)), decipher.final()]).toString('utf8');
-            }
-            catch {
-                return null;
-            }
-        }
-        it('round-trips a short cookie value', () => {
-            const value = 'ESTSAUTHPERSISTENT_VALUE_HERE';
-            expect(decrypt(encrypt(value))).toBe(value);
-        });
-        it('round-trips an empty string', () => {
-            expect(decrypt(encrypt(''))).toBe('');
-        });
-        it('round-trips a long value (>1 AES block)', () => {
-            const value = 'A'.repeat(200);
-            expect(decrypt(encrypt(value))).toBe(value);
-        });
-        it('returns raw string for non-v10 prefix', () => {
-            const plain = Buffer.from('hello');
-            expect(decrypt(plain.toString('hex'))).toBe('hello');
-        });
-        it('returns null for corrupted ciphertext', () => {
-            // Valid v10 prefix but garbage data
-            const garbage = Buffer.concat([Buffer.from('v10'), Buffer.from('not-valid-ciphertext-at-all!!')]);
-            expect(decrypt(garbage.toString('hex'))).toBeNull();
-        });
-    });
-    describe('Chrome epoch conversion', () => {
-        function chromeEpochToUnix(chromeTimestamp) {
-            return Math.floor(chromeTimestamp / 1_000_000) - 11644473600;
-        }
-        it('converts a known Chrome timestamp to Unix', () => {
-            // 2025-01-01T00:00:00Z in Unix = 1735689600
-            // In Chrome epoch = (1735689600 + 11644473600) * 1_000_000 = 13380163200000000
-            const chromeTs = 13380163200000000;
-            expect(chromeEpochToUnix(chromeTs)).toBe(1735689600);
-        });
-        it('returns 0 for the Unix epoch in Chrome time', () => {
-            const chromeTs = 11644473600 * 1_000_000;
-            expect(chromeEpochToUnix(chromeTs)).toBe(0);
-        });
-    });
-    describe('samesite mapping', () => {
-        function chromeSameSiteToPlaywright(samesite) {
-            switch (samesite) {
-                case 2: return 'Strict';
-                case 1: return 'Lax';
-                default: return 'None';
-            }
-        }
-        it('maps Chrome samesite values', () => {
-            expect(chromeSameSiteToPlaywright(-1)).toBe('None');
-            expect(chromeSameSiteToPlaywright(0)).toBe('None');
-            expect(chromeSameSiteToPlaywright(1)).toBe('Lax');
-            expect(chromeSameSiteToPlaywright(2)).toBe('Strict');
-        });
-    });
-    describe('profile detection heuristics', () => {
-        const profiles = [
-            { dirName: 'Default', name: 'Person 1', gaiaName: 'Test' },
-            { dirName: 'Profile 1', name: 'corp.example.com', gaiaName: 'Jane Smith' },
-            { dirName: 'Profile 2', name: 'Jane', gaiaName: 'Jane Smith' },
-            { dirName: 'Profile 4', name: 'Test', gaiaName: '' },
-        ];
-        function selectWorkProfile(profiles) {
-            return profiles.find(p => /\.[a-z]{2,}$/i.test(p.name) ||
-                p.name.toLowerCase().includes('work') ||
-                p.name.toLowerCase().includes('corp')) ?? null;
-        }
-        it('selects profile with domain-like name', () => {
-            expect(selectWorkProfile(profiles)?.dirName).toBe('Profile 1');
-        });
-        it('selects profile with "work" in name', () => {
-            const custom = [
-                { dirName: 'Default', name: 'Personal' },
-                { dirName: 'Profile 1', name: 'Work Account' },
-            ];
-            expect(selectWorkProfile(custom)?.dirName).toBe('Profile 1');
-        });
-        it('selects profile with "corp" in name', () => {
-            const custom = [
-                { dirName: 'Default', name: 'Me' },
-                { dirName: 'Profile 1', name: 'CorpNet' },
-            ];
-            expect(selectWorkProfile(custom)?.dirName).toBe('Profile 1');
-        });
-        it('returns null when no work profile found', () => {
-            const custom = [
-                { dirName: 'Default', name: 'Person 1' },
-                { dirName: 'Profile 2', name: 'Gaming' },
-            ];
-            expect(selectWorkProfile(custom)).toBeNull();
-        });
-    });
-});

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

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1,175 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-/**
- * 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 {};