msteams-mcp 0.14.3 → 0.15.3

package/dist/api/chatsvc-api.js

@@ -10,7 +10,7 @@ import { ErrorCode, createError } from '../types/errors.js';
 import { ok, err } from '../types/result.js';
 import { getUserDisplayName } from '../auth/token-extractor.js';
 import { requireMessageAuth, getRegion, getTeamsBaseUrl } from '../utils/auth-guards.js';
-import { stripHtml, extractLinks, buildMessageLink, buildOneOnOneConversationId, extractObjectId, extractActivityTimestamp, parseVirtualConversationMessage } from '../utils/parsers.js';
+import { stripHtml, extractLinks, buildMessageLink, buildOneOnOneConversationId, extractObjectId, extractActivityTimestamp, parseVirtualConversationMessage, markdownToTeamsHtml } from '../utils/parsers.js';
 import { DEFAULT_ACTIVITY_LIMIT, SAVED_MESSAGES_ID, FOLLOWED_THREADS_ID, VIRTUAL_CONVERSATION_PREFIX, SELF_CHAT_ID, MRI_ORGID_PREFIX } from '../constants.js';
 // Reusable date formatter for human-readable timestamps with day of week
 // Hoisted to module scope to avoid creating a new formatter per message
@@ -68,23 +68,12 @@ export async function sendMessage(conversationId, content, options = {}) {
     const displayName = getUserDisplayName() || 'User';
     // Generate unique message ID
     const clientMessageId = Date.now().toString();
-    // Process content: handle mentions and links
-    let processedContent;
-    let mentionsToSend = [];
-    // If content is already HTML, pass through as-is
-    if (content.startsWith('<')) {
-        processedContent = content;
-    }
-    else {
-        // Process mentions and links together
-        const parsed = parseContentWithMentionsAndLinks(content);
-        processedContent = parsed.html;
-        mentionsToSend = parsed.mentions;
-    }
-    // Wrap content in paragraph if not already HTML
-    const htmlContent = processedContent.startsWith('<')
-        ? processedContent
-        : `<p>${processedContent}</p>`;
+    // Process content: handle mentions, links, and markdown formatting
+    // Always convert through markdown→HTML pipeline (never pass raw HTML through,
+    // as Teams requires proper block-level wrapping like <p> tags)
+    const parsed = parseContentWithMentionsAndLinks(content);
+    const htmlContent = parsed.html;
+    const mentionsToSend = parsed.mentions;
     // Build the message body
     const body = {
         content: htmlContent,
@@ -388,8 +377,9 @@ export async function editMessage(conversationId, messageId, newContent) {
     const auth = authResult.value;
     const { region, baseUrl } = getApiConfig();
     const displayName = getUserDisplayName() || 'User';
-    // Wrap content in paragraph if not already HTML
-    const htmlContent = newContent.startsWith('<') ? newContent : `<p>${escapeHtml(newContent)}</p>`;
+    // Always convert through markdown→HTML pipeline (never pass raw HTML through,
+    // as Teams requires proper block-level wrapping like <p> tags)
+    const htmlContent = markdownToTeamsHtml(newContent);
     // Build the edit request body
     // The API requires the message structure with updated content
     const body = {
@@ -624,30 +614,43 @@ function parseContentWithMentionsAndLinks(content) {
         ...findAll(mentionPattern, 'mention'),
         ...findAll(linkPattern, 'link'),
     ].sort((a, b) => a.index - b.index);
-    // Build result
+    // No mentions or links - use full markdown conversion
+    if (matches.length === 0) {
+        return { html: markdownToTeamsHtml(content), mentions: [] };
+    }
+    // Strategy: replace mentions/links with unique placeholders, run the whole
+    // content through markdownToTeamsHtml (so links stay inline within their
+    // paragraph), then substitute placeholders back with actual HTML.
     const mentions = [];
-    let result = '';
-    let lastIndex = 0;
+    const placeholders = new Map();
     let mentionId = 0;
-    for (const m of matches) {
-        // Add escaped text before this match
-        const textBefore = content.substring(lastIndex, m.index);
-        result += escapeHtml(textBefore);
+    // Build content with placeholders (process in reverse to preserve indices)
+    let placeholderContent = content;
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const m = matches[i];
+        const placeholder = `\uE000MCP_PH_${i}\uE001`;
+        let html;
         if (m.type === 'mention') {
             mentions.push({ mri: m.target, displayName: m.text });
-            result += buildMentionHtml(m.text, mentionId);
+            html = buildMentionHtml(m.text, mentionId);
             mentionId++;
         }
         else {
-            // Link
             const safeText = escapeHtml(m.text);
             const safeUrl = m.target.replace(/"/g, '&quot;');
-            result += `<a href="${safeUrl}">${safeText}</a>`;
+            html = `<a href="${safeUrl}">${safeText}</a>`;
         }
-        lastIndex = m.index + m.length;
+        placeholders.set(placeholder, html);
+        placeholderContent = placeholderContent.substring(0, m.index) + placeholder + placeholderContent.substring(m.index + m.length);
+    }
+    // Reverse mentions array since we processed in reverse order
+    mentions.reverse();
+    // Convert the whole content (with placeholders) through markdown pipeline
+    let result = markdownToTeamsHtml(placeholderContent);
+    // Substitute placeholders back with actual HTML
+    for (const [placeholder, html] of placeholders) {
+        result = result.replace(placeholder, html);
     }
-    // Add remaining text
-    result += escapeHtml(content.substring(lastIndex));
     return { html: result, mentions };
 }
 /**

package/dist/browser/auth.js

@@ -4,7 +4,6 @@
  */
 import { saveSessionState } from './context.js';
 import { OVERLAY_STEP_PAUSE_MS, OVERLAY_COMPLETE_PAUSE_MS, } from '../constants.js';
-import { extractSubstrateToken, clearTokenCache } from '../auth/token-extractor.js';
 /**
  * Default Teams URL for initial login.
  *
@@ -285,18 +284,61 @@ async function hasAuthenticatedContent(page) {
     }
     return false;
 }
+/**
+ * Waits for the Teams SPA to be fully loaded and interactive.
+ *
+ * Teams is a heavy SPA — after navigation, the shell loads quickly but MSAL
+ * (which manages tokens) needs time to bootstrap. We wait for key UI elements
+ * that only render after the app has fully initialised, then wait for network
+ * activity to settle (indicating MSAL token requests have completed).
+ */
+async function waitForTeamsReady(page, log, timeoutMs = 60000) {
+    log('Waiting for Teams to fully load...');
+    try {
+        // Wait for any SPA UI element that indicates the app has bootstrapped
+        await page.waitForSelector(AUTH_SUCCESS_SELECTORS.join(', '), { timeout: timeoutMs });
+        log('Teams UI elements detected.');
+        // Wait for network to settle — MSAL token refresh requests should complete
+        try {
+            await page.waitForLoadState('networkidle', { timeout: 15000 });
+            log('Network settled.');
+        }
+        catch {
+            // Network may not become fully idle (websockets, polling), that's OK
+            log('Network did not fully settle, continuing...');
+        }
+        return true;
+    }
+    catch {
+        log('Teams did not fully load within timeout.');
+        return false;
+    }
+}
 /**
  * Triggers MSAL to acquire the Substrate token.
  *
  * MSAL only acquires tokens for specific scopes when the app makes API calls
  * requiring those scopes. The Substrate API is only used for search, so we
- * perform a minimal search ("is:Messages") to trigger token acquisition.
+ * perform a search to trigger token acquisition.
+ *
+ * Returns true if a Substrate API call was detected, false otherwise.
  */
 async function triggerTokenAcquisition(page, log) {
     log('Triggering token acquisition...');
     try {
-        // Wait for the app to be ready
-        await page.waitForTimeout(5000);
+        // Wait for Teams SPA to be fully loaded (MSAL must bootstrap first)
+        const ready = await waitForTeamsReady(page, log);
+        if (!ready) {
+            log('Teams did not load — cannot trigger token acquisition.');
+            return false;
+        }
+        // Set up Substrate API listener BEFORE triggering search
+        let substrateDetected = false;
+        const substratePromise = page.waitForResponse(resp => resp.url().includes('substrate.office.com') && resp.status() === 200, { timeout: 30000 }).then(() => {
+            substrateDetected = true;
+        }).catch(() => {
+            // Timeout — no Substrate call detected
+        });
         // Try multiple methods to trigger search
         let searchTriggered = false;
         // Method 1: Navigate to search results URL (triggers Substrate API call directly)
@@ -306,7 +348,6 @@ async function triggerTokenAcquisition(page, log) {
                 waitUntil: 'domcontentloaded',
                 timeout: 30000,
             });
-            await page.waitForTimeout(5000);
             searchTriggered = true;
             log('Search results page loaded.');
         }
@@ -355,28 +396,31 @@ async function triggerTokenAcquisition(page, log) {
             await page.keyboard.press('Enter');
             searchTriggered = true;
         }
-        // Wait for the Substrate search API call to complete
-        log('Waiting for search API...');
-        try {
-            // Wait for the actual API request to substrate.office.com
-            await Promise.race([
-                page.waitForResponse(resp => resp.url().includes('substrate.office.com') && resp.status() === 200, { timeout: 15000 }),
-                page.waitForTimeout(15000),
-            ]);
-            log('Substrate API call detected.');
+        // Wait for the Substrate API response
+        log('Waiting for Substrate API...');
+        await substratePromise;
+        if (substrateDetected) {
+            log('Substrate API call detected — tokens acquired.');
         }
-        catch {
-            log('No Substrate API call detected, continuing...');
+        else {
+            log('No Substrate API call detected within timeout.');
         }
+        // Give MSAL a moment to persist tokens to localStorage
         await page.waitForTimeout(2000);
         // Close search and reset
-        await page.keyboard.press('Escape');
-        await page.waitForTimeout(1000);
+        try {
+            await page.keyboard.press('Escape');
+            await page.waitForTimeout(500);
+        }
+        catch {
+            // Page may have navigated, ignore
+        }
         log('Token acquisition complete.');
+        return substrateDetected;
     }
     catch (error) {
         log(`Token acquisition warning: ${error instanceof Error ? error.message : String(error)}`);
-        await page.waitForTimeout(3000);
+        return false;
     }
 }
 /**
@@ -517,23 +561,20 @@ export async function waitForManualLogin(page, context, timeoutMs = 5 * 60 * 100
                 await showLoginProgress(page, 'acquiring');
             }
             // Trigger a search to cause MSAL to acquire the Substrate token
-            await triggerTokenAcquisition(page, log);
+            const acquired = await triggerTokenAcquisition(page, log);
+            if (!acquired) {
+                log('Warning: Substrate API call was not detected after login.');
+                if (showOverlay) {
+                    await showLoginProgress(page, 'error', { pause: true });
+                }
+                throw new Error('Login completed but token acquisition failed. Please try again.');
+            }
             if (showOverlay) {
                 await showLoginProgress(page, 'saving');
             }
             // Save the session state with fresh tokens
             await saveSessionState(context);
-            clearTokenCache();
             log('Session state saved.');
-            // Verify tokens were actually acquired
-            const token = extractSubstrateToken();
-            if (!token || token.expiry.getTime() <= Date.now()) {
-                log('Warning: No valid Substrate token found after login. You may need to try again.');
-                if (showOverlay) {
-                    await showLoginProgress(page, 'error', { pause: true });
-                }
-                throw new Error('Login completed but token acquisition failed. Please try again.');
-            }
             if (showOverlay) {
                 await showLoginProgress(page, 'complete', { pause: true });
             }
@@ -566,39 +607,23 @@ export async function ensureAuthenticated(page, context, onProgress, showOverlay
     const status = await navigateToTeams(page);
     if (status.isAuthenticated) {
         log('Already authenticated.');
-        // Snapshot token expiry before refresh attempt
-        const beforeToken = extractSubstrateToken();
-        const beforeExpiry = beforeToken?.expiry?.getTime() ?? 0;
         if (showOverlay) {
             await showLoginProgress(page, 'refreshing');
         }
         // Trigger a search to cause MSAL to acquire/refresh the Substrate token
-        await triggerTokenAcquisition(page, log);
+        const acquired = await triggerTokenAcquisition(page, log);
+        if (!acquired) {
+            log('Token refresh failed: Substrate API call was not detected.');
+            if (showOverlay) {
+                await showLoginProgress(page, 'error', { pause: true });
+            }
+            throw new Error('Token refresh failed. Please use teams_login with forceNew to re-authenticate.');
+        }
         if (showOverlay) {
             await showLoginProgress(page, 'saving');
         }
         // Save the session state with fresh tokens
         await saveSessionState(context);
-        // Clear token cache so we re-extract from the freshly saved session
-        clearTokenCache();
-        // Verify tokens were actually refreshed
-        const afterToken = extractSubstrateToken();
-        const afterExpiry = afterToken?.expiry?.getTime() ?? 0;
-        const tokenIsValid = afterToken !== null && afterExpiry > Date.now();
-        const tokenWasRefreshed = afterExpiry > beforeExpiry;
-        if (!tokenIsValid) {
-            log('Warning: No valid token found after refresh attempt.');
-            if (headless) {
-                throw new Error('Token refresh failed: no valid token after SSO. Browser-based re-authentication required.');
-            }
-        }
-        else if (!tokenWasRefreshed && beforeToken && beforeExpiry <= Date.now() + 10 * 60 * 1000) {
-            // Token was close to expiry but wasn't refreshed - MSAL likely didn't initialise in time
-            log('Warning: Token was not refreshed despite being close to expiry.');
-            if (headless) {
-                throw new Error('Token refresh failed: token not refreshed despite being close to expiry. Browser-based re-authentication required.');
-            }
-        }
         if (showOverlay) {
             await showLoginProgress(page, 'complete', { pause: true });
         }

package/dist/tools/message-tools.js

@@ -72,13 +72,13 @@ export const GetFollowedThreadsInputSchema = z.object({
 // ─────────────────────────────────────────────────────────────────────────────
 const sendMessageToolDefinition = {
     name: 'teams_send_message',
-    description: 'Send a message to a Teams conversation. Supports @mentions using @[Name](mri) syntax inline. Example: "Hey @[John Smith](8:orgid:abc...), check this". Get MRI from teams_search_people. Defaults to self-notes (48:notes). For channel thread replies, provide replyToMessageId.',
+    description: 'Send a message to a Teams conversation. Use markdown for formatting (not HTML): **bold**, *italic*, ~~strikethrough~~, `code`, ```code blocks```, lists, and newlines. Supports @mentions using @[Name](mri) syntax inline. Example: "Hey @[John Smith](8:orgid:abc...), check this". Get MRI from teams_search_people. Defaults to self-notes (48:notes). For channel thread replies, provide replyToMessageId.',
     inputSchema: {
         type: 'object',
         properties: {
             content: {
                 type: 'string',
-                description: 'The message content. For @mentions, use @[DisplayName](mri) syntax. Example: "Hey @[John Smith](8:orgid:abc...), can you review this?"',
+                description: 'The message content in markdown (not HTML). Supports: **bold**, *italic*, ~~strikethrough~~, `inline code`, ```code blocks```, bullet lists (- item), numbered lists (1. item), and newlines. Do NOT send raw HTML tags. For @mentions, use @[DisplayName](mri) syntax. Example: "Hey @[John Smith](8:orgid:abc...), can you review this?"',
             },
             conversationId: {
                 type: 'string',

package/dist/utils/parsers.d.ts

@@ -218,6 +218,27 @@ export declare function buildOneOnOneConversationId(userId1: string, userId2: st
  * @returns ISO timestamp string, or null if no valid timestamp found
  */
 export declare function extractActivityTimestamp(msg: Record<string, unknown>): string | null;
+/**
+ * Converts markdown-formatted text to Teams-compatible HTML.
+ *
+ * Supports:
+ * - **bold** / __bold__ → <b>
+ * - *italic* / _italic_ → <i>
+ * - ~~strikethrough~~ → <s>
+ * - `inline code` → <code>
+ * - ```code blocks``` → <pre><code>
+ * - Newlines → paragraph breaks
+ * - Ordered lists (1. item) → <ol><li>
+ * - Unordered lists (- item, * item) → <ul><li>
+ *
+ * Plain text without any formatting is returned as-is (HTML-escaped).
+ */
+export declare function markdownToTeamsHtml(text: string): string;
+/**
+ * Checks whether text contains any markdown formatting that would
+ * benefit from conversion to HTML.
+ */
+export declare function hasMarkdownFormatting(text: string): boolean;
 /** Common fields from a virtual conversation message (48:saved, 48:threads, etc). */
 export interface VirtualConversationItem {
     id: string;

package/dist/utils/parsers.js

@@ -669,6 +669,155 @@ export function extractActivityTimestamp(msg) {
     }
     return null;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Markdown to Teams HTML Conversion
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Escapes HTML special characters in text.
+ */
+function escapeHtmlChars(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Converts inline markdown formatting to Teams HTML within a single line.
+ * Handles: bold, italic, strikethrough, inline code.
+ * Text outside of formatting markers is HTML-escaped.
+ */
+function convertInlineFormatting(line) {
+    // Process inline code first (to prevent other formatting inside code spans)
+    // Split on `code` patterns, escape and format alternately
+    const codeParts = line.split(/`([^`]+)`/);
+    let result = '';
+    for (let i = 0; i < codeParts.length; i++) {
+        if (i % 2 === 1) {
+            // Inside backticks - render as code, only escape HTML
+            result += `<code>${escapeHtmlChars(codeParts[i])}</code>`;
+        }
+        else {
+            // Outside backticks - process other inline formatting
+            let segment = escapeHtmlChars(codeParts[i]);
+            // Bold: **text** or __text__
+            segment = segment.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+            segment = segment.replace(/__(.+?)__/g, '<b>$1</b>');
+            // Italic: *text* or _text_ (but not inside words for underscore)
+            segment = segment.replace(/\*(.+?)\*/g, '<i>$1</i>');
+            segment = segment.replace(/(?<!\w)_(.+?)_(?!\w)/g, '<i>$1</i>');
+            // Strikethrough: ~~text~~
+            segment = segment.replace(/~~(.+?)~~/g, '<s>$1</s>');
+            result += segment;
+        }
+    }
+    return result;
+}
+/**
+ * Converts markdown-formatted text to Teams-compatible HTML.
+ *
+ * Supports:
+ * - **bold** / __bold__ → <b>
+ * - *italic* / _italic_ → <i>
+ * - ~~strikethrough~~ → <s>
+ * - `inline code` → <code>
+ * - ```code blocks``` → <pre><code>
+ * - Newlines → paragraph breaks
+ * - Ordered lists (1. item) → <ol><li>
+ * - Unordered lists (- item, * item) → <ul><li>
+ *
+ * Plain text without any formatting is returned as-is (HTML-escaped).
+ */
+export function markdownToTeamsHtml(text) {
+    // Handle fenced code blocks first (```...```)
+    // Split text into code blocks and non-code-block segments
+    const segments = [];
+    const codeBlockRegex = /```(\w*)\n?([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        // Text before this code block
+        if (match.index > lastIndex) {
+            segments.push({ type: 'text', content: text.substring(lastIndex, match.index) });
+        }
+        segments.push({ type: 'codeblock', content: match[2], lang: match[1] || undefined });
+        lastIndex = match.index + match[0].length;
+    }
+    // Remaining text after last code block
+    if (lastIndex < text.length) {
+        segments.push({ type: 'text', content: text.substring(lastIndex) });
+    }
+    const htmlParts = [];
+    for (const segment of segments) {
+        if (segment.type === 'codeblock') {
+            // Code blocks: escape HTML but preserve whitespace
+            const escaped = escapeHtmlChars(segment.content.replace(/\n$/, ''));
+            htmlParts.push(`<pre><code>${escaped}</code></pre>`);
+            continue;
+        }
+        // Process text segments: split into paragraphs on double newlines
+        const paragraphs = segment.content.split(/\n{2,}/);
+        for (const para of paragraphs) {
+            const trimmed = para.trim();
+            if (!trimmed)
+                continue;
+            const lines = trimmed.split('\n');
+            // Check if this paragraph is a list
+            const isUnorderedList = lines.every(l => /^\s*[-*]\s+/.test(l));
+            const isOrderedList = lines.every(l => /^\s*\d+[.)]\s+/.test(l));
+            if (isUnorderedList) {
+                const items = lines.map(l => {
+                    const content = l.replace(/^\s*[-*]\s+/, '');
+                    return `<li>${convertInlineFormatting(content)}</li>`;
+                });
+                htmlParts.push(`<ul>${items.join('')}</ul>`);
+            }
+            else if (isOrderedList) {
+                const items = lines.map(l => {
+                    const content = l.replace(/^\s*\d+[.)]\s+/, '');
+                    return `<li>${convertInlineFormatting(content)}</li>`;
+                });
+                htmlParts.push(`<ol>${items.join('')}</ol>`);
+            }
+            else {
+                // Regular paragraph - join lines with <br>
+                const htmlLines = lines.map(l => convertInlineFormatting(l));
+                htmlParts.push(`<p>${htmlLines.join('<br>')}</p>`);
+            }
+        }
+    }
+    return htmlParts.join('') || '<p></p>';
+}
+/**
+ * Checks whether text contains any markdown formatting that would
+ * benefit from conversion to HTML.
+ */
+export function hasMarkdownFormatting(text) {
+    // Code blocks
+    if (/```[\s\S]*```/.test(text))
+        return true;
+    // Inline code
+    if (/`[^`]+`/.test(text))
+        return true;
+    // Bold
+    if (/\*\*.+?\*\*/.test(text) || /__.+?__/.test(text))
+        return true;
+    // Italic (single * or _)
+    if (/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/.test(text))
+        return true;
+    // Strikethrough
+    if (/~~.+?~~/.test(text))
+        return true;
+    // Lists
+    if (/^\s*[-*]\s+/m.test(text))
+        return true;
+    if (/^\s*\d+[.)]\s+/m.test(text))
+        return true;
+    // Multiple newlines (paragraph breaks)
+    if (/\n/.test(text))
+        return true;
+    return false;
+}
 /**
  * Parses a raw message from a virtual conversation (48:saved, 48:threads, etc).
  *

package/dist/utils/parsers.test.js

@@ -5,7 +5,7 @@
  * produce expected outputs regardless of internal logic.
  */
 import { describe, it, expect } from 'vitest';
-import { stripHtml, extractLinks, buildMessageLink, getConversationType, extractMessageTimestamp, parsePersonSuggestion, parseV2Result, parseJwtProfile, calculateTokenStatus, parseSearchResults, parsePeopleResults, extractObjectId, buildOneOnOneConversationId, decodeBase64Guid, extractActivityTimestamp, } from './parsers.js';
+import { stripHtml, extractLinks, buildMessageLink, getConversationType, extractMessageTimestamp, parsePersonSuggestion, parseV2Result, parseJwtProfile, calculateTokenStatus, parseSearchResults, parsePeopleResults, extractObjectId, buildOneOnOneConversationId, decodeBase64Guid, extractActivityTimestamp, markdownToTeamsHtml, } from './parsers.js';
 import { searchResultItem, searchResultWithHtml, searchResultMinimal, searchResultTooShort, searchResultThreadReply, searchEntitySetsResponse, personSuggestion, personMinimal, personWithBase64Id, peopleGroupsResponse, jwtPayloadFull, jwtPayloadMinimal, jwtPayloadCommaName, jwtPayloadSpaceName, sourceWithMessageId, sourceWithConvIdMessageId, } from '../__fixtures__/api-responses.js';
 describe('stripHtml', () => {
     it('removes HTML tags', () => {
@@ -509,3 +509,75 @@ describe('extractActivityTimestamp', () => {
         expect(extractActivityTimestamp(msg)).toBeNull();
     });
 });
+describe('markdownToTeamsHtml', () => {
+    it('wraps plain text in paragraph tags', () => {
+        expect(markdownToTeamsHtml('Hello world')).toBe('<p>Hello world</p>');
+    });
+    it('escapes HTML special characters', () => {
+        expect(markdownToTeamsHtml('1 < 2 & 3 > 0')).toBe('<p>1 &lt; 2 &amp; 3 &gt; 0</p>');
+    });
+    it('converts bold markdown', () => {
+        expect(markdownToTeamsHtml('This is **bold** text')).toBe('<p>This is <b>bold</b> text</p>');
+        expect(markdownToTeamsHtml('This is __bold__ text')).toBe('<p>This is <b>bold</b> text</p>');
+    });
+    it('converts italic markdown', () => {
+        expect(markdownToTeamsHtml('This is *italic* text')).toBe('<p>This is <i>italic</i> text</p>');
+    });
+    it('converts strikethrough markdown', () => {
+        expect(markdownToTeamsHtml('This is ~~deleted~~ text')).toBe('<p>This is <s>deleted</s> text</p>');
+    });
+    it('converts inline code', () => {
+        expect(markdownToTeamsHtml('Use `console.log()` here')).toBe('<p>Use <code>console.log()</code> here</p>');
+    });
+    it('does not process markdown inside inline code', () => {
+        expect(markdownToTeamsHtml('Use `**not bold**` here')).toBe('<p>Use <code>**not bold**</code> here</p>');
+    });
+    it('escapes HTML inside inline code', () => {
+        expect(markdownToTeamsHtml('Use `<div>` tag')).toBe('<p>Use <code>&lt;div&gt;</code> tag</p>');
+    });
+    it('converts fenced code blocks', () => {
+        expect(markdownToTeamsHtml('```\nconst x = 1;\n```')).toBe('<pre><code>const x = 1;</code></pre>');
+    });
+    it('converts fenced code blocks with language', () => {
+        expect(markdownToTeamsHtml('```js\nconst x = 1;\n```')).toBe('<pre><code>const x = 1;</code></pre>');
+    });
+    it('escapes HTML inside code blocks', () => {
+        expect(markdownToTeamsHtml('```\n<div>test</div>\n```')).toBe('<pre><code>&lt;div&gt;test&lt;/div&gt;</code></pre>');
+    });
+    it('handles text before and after code blocks', () => {
+        const input = 'Before\n\n```\ncode\n```\n\nAfter';
+        expect(markdownToTeamsHtml(input)).toBe('<p>Before</p><pre><code>code</code></pre><p>After</p>');
+    });
+    it('converts single newlines to br tags', () => {
+        expect(markdownToTeamsHtml('Line 1\nLine 2')).toBe('<p>Line 1<br>Line 2</p>');
+    });
+    it('converts double newlines to separate paragraphs', () => {
+        expect(markdownToTeamsHtml('Para 1\n\nPara 2')).toBe('<p>Para 1</p><p>Para 2</p>');
+    });
+    it('converts unordered lists', () => {
+        expect(markdownToTeamsHtml('- Item 1\n- Item 2\n- Item 3')).toBe('<ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>');
+    });
+    it('converts unordered lists with * marker', () => {
+        expect(markdownToTeamsHtml('* Item 1\n* Item 2')).toBe('<ul><li>Item 1</li><li>Item 2</li></ul>');
+    });
+    it('converts ordered lists', () => {
+        expect(markdownToTeamsHtml('1. First\n2. Second\n3. Third')).toBe('<ol><li>First</li><li>Second</li><li>Third</li></ol>');
+    });
+    it('handles inline formatting inside list items', () => {
+        expect(markdownToTeamsHtml('- **Bold** item\n- *Italic* item')).toBe('<ul><li><b>Bold</b> item</li><li><i>Italic</i> item</li></ul>');
+    });
+    it('handles combined formatting', () => {
+        const input = '**Bold** and *italic* and `code`';
+        expect(markdownToTeamsHtml(input)).toBe('<p><b>Bold</b> and <i>italic</i> and <code>code</code></p>');
+    });
+    it('handles complex multi-paragraph message', () => {
+        const input = 'Hello **team**!\n\nHere are the updates:\n\n- Item 1\n- Item 2\n\nThanks!';
+        expect(markdownToTeamsHtml(input)).toBe('<p>Hello <b>team</b>!</p><p>Here are the updates:</p><ul><li>Item 1</li><li>Item 2</li></ul><p>Thanks!</p>');
+    });
+    it('returns empty paragraph for empty string', () => {
+        expect(markdownToTeamsHtml('')).toBe('<p></p>');
+    });
+    it('handles whitespace-only input', () => {
+        expect(markdownToTeamsHtml('   ')).toBe('<p></p>');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msteams-mcp",
-  "version": "0.14.3",
+  "version": "0.15.3",
   "description": "MCP server for Microsoft Teams - search messages, send replies, manage favourites",
   "type": "module",
   "main": "dist/index.js",