@mindstone/mcp-server-microsoft-teams 0.1.2 → 0.3.0

package/dist/tools.js

@@ -1,7 +1,27 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { hasScope } from '@mindstone/mcp-server-microsoft-shared';
 import { z } from 'zod';
-import { callGraph } from './client.js';
-import { successJson, withErrorHandling } from './utils.js';
-import { getChat, getPresence, listChannels, listChats, listChatMessages, listTeams, sendChatMessage, } from './teams.js';
+import { callGraph, getTokenProvider } from './client.js';
+import { errorResponse, successJson, withErrorHandling } from './utils.js';
+import { AUTH_TOOL_NAME } from './types.js';
+import { createChat, findUser, getChat, getPresence, getUserPresence, listChannelMessages, listChannels, listChats, listChatMessages, listTeams, PRESENCE_AVAILABILITY_VALUES, replyToChannelMessage, replyToChatMessage, searchMessages, sendChannelMessage, sendChatMessage, setPresence, } from './teams.js';
+/**
+ * `ui://` resource URI the compose_chat_message iframe is served under. The
+ * shared compose-app template posts `send_chat_message` when the user clicks
+ * Send; the HTML twin lives in src/resources/compose-message-template.ts
+ * (generated from the shared compose-app package, drift-gated).
+ */
+export const COMPOSE_MESSAGE_RESOURCE_URI = 'ui://microsoft-teams/compose-message';
+const ANSI_ESCAPE_SEQUENCE_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const HTML_TAG_PATTERN = /<[^>]*>/g;
+function truncateText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function sanitizeViewSummaryPart(value) {
+    return value.replace(ANSI_ESCAPE_SEQUENCE_PATTERN, '').replace(HTML_TAG_PATTERN, '').trim();
+}
 const READ_ANNOTATIONS = {
     readOnlyHint: true,
     openWorldHint: true,
@@ -11,6 +31,52 @@ const WRITE_ANNOTATIONS = {
     destructiveHint: false,
     openWorldHint: true,
 };
+// Tools that change external state (send messages, create chats, set presence)
+// must declare destructiveHint so hosts can gate or confirm them — AGENTS.md
+// security invariant #7. compose_chat_message keeps the plain write
+// annotations: it returns an editable draft and performs no Graph send itself.
+const DESTRUCTIVE_WRITE_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: true,
+};
+/**
+ * Some Teams Graph surfaces (channel messages, user lookup, other users'
+ * presence) need delegated permissions beyond the cohort's base scope set,
+ * and several are admin-consent-gated under Microsoft's managed consent
+ * policy. When the connected account's token lacks the scope, return an
+ * actionable error up front instead of letting Graph 403 — same pattern as
+ * the SharePoint connector's Sites.Read.All gate. When there is no token on
+ * disk yet, fall through to the real call so the standard auth_required
+ * envelope handles it. A token that fails to LOAD (corrupt file, unreadable
+ * disk, provider error) is different from "no token": fail closed with
+ * observable guidance instead of silently skipping the permission gate.
+ */
+async function requireScopesGranted(requiredScopes, feature) {
+    let tokenScope;
+    try {
+        const tokenData = await getTokenProvider().loadToken();
+        if (!tokenData)
+            return null;
+        tokenScope = tokenData.scope;
+    }
+    catch (err) {
+        return errorResponse({
+            error: `${feature} could not verify the Microsoft Graph permissions granted to the connected account: ${err instanceof Error ? err.message : String(err)}`,
+            action_required: 'Reconnect the Microsoft account so the granted permissions can be verified. In many organizations an administrator must approve these permissions first.',
+            next_step: AUTH_TOOL_NAME,
+        });
+    }
+    const missing = requiredScopes.filter((scope) => !hasScope(tokenScope, scope));
+    if (missing.length === 0)
+        return null;
+    return errorResponse({
+        error: `${feature} requires Microsoft Graph permission(s) not granted to the connected account: ${missing.join(', ')}.`,
+        action_required: 'Reconnect the Microsoft account with the additional permissions. In many organizations an administrator must approve these permissions first.',
+        next_step: AUTH_TOOL_NAME,
+        missing_scopes: missing,
+    });
+}
 export function registerTeamsTools(server) {
     server.registerTool('list_chats', {
         description: 'List recent Teams chats (1:1, group, and meeting chats).',
@@ -34,14 +100,118 @@ export function registerTeamsTools(server) {
         }).shape,
         annotations: READ_ANNOTATIONS,
     }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => listChatMessages(c, args, signal)))));
+    // ---------------------------------------------------------------------
+    // compose_chat_message
+    // ---------------------------------------------------------------------
+    // Returns an editable draft the host renders as an interactive compose view
+    // (the compose-message iframe). Performs no Graph send itself — the iframe
+    // invokes send_chat_message when the user clicks Send. Registered WITHOUT
+    // withErrorHandling: it does no send I/O, and its InvalidParams validation
+    // must surface as-is rather than as an auth-flavoured retry envelope. Teams
+    // routes purely by chatId, so there is no recipient resolution (unlike Slack
+    // DMs) — the draft carries the target chat + text verbatim.
+    server.registerTool('compose_chat_message', {
+        description: `Open an inline editable message compose form before sending to a Teams chat. Use this when the user wants to write or send a Teams message so they can review and edit it first. Does NOT send directly — the form posts the message (via send_chat_message) when the user clicks Send.
+
+PARAMETERS: target (the chat ID to send to), text (message content).`,
+        inputSchema: z
+            .object({
+            target: z.string().min(1).describe('The chat ID to send the message to'),
+            text: z.string().min(1).describe('Message content (HTML supported)'),
+        })
+            .strict(),
+        annotations: WRITE_ANNOTATIONS,
+    }, async (args) => {
+        const target = typeof args.target === 'string' ? args.target.trim() : '';
+        const text = typeof args.text === 'string' ? args.text : '';
+        if (target.length === 0 || text.trim().length === 0) {
+            throw new McpError(ErrorCode.InvalidParams, 'compose_chat_message requires a non-empty "target" (chat ID) and "text". Provide both so the editable draft has content for the user to review.');
+        }
+        const structuredContent = { target, text };
+        const viewSummaryTarget = truncateText(sanitizeViewSummaryPart(target), 120);
+        const viewSummary = truncateText(`Teams message draft to ${viewSummaryTarget || '(no target)'}.`, 280);
+        const fallbackTarget = truncateText(target, 256);
+        const fallbackText = truncateText(text, 5_000);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Drafting a Teams message to ${target}\n\n${JSON.stringify(structuredContent)}\n\n[View: ${COMPOSE_MESSAGE_RESOURCE_URI}]`,
+                },
+            ],
+            _meta: {
+                ui: {
+                    resourceUri: COMPOSE_MESSAGE_RESOURCE_URI,
+                    presentation: 'primary',
+                    viewSummary,
+                    viewRoleLabel: 'Teams message',
+                    structuredFallback: {
+                        kind: 'plain',
+                        payload: {
+                            markdown: `Message to ${fallbackTarget}:\n\n${fallbackText}`,
+                        },
+                    },
+                },
+            },
+            structuredContent,
+        };
+    });
     server.registerTool('send_chat_message', {
         description: 'Send a message to a chat.',
         inputSchema: z.object({
             chatId: z.string().describe('Chat ID'),
             content: z.string().describe('Message content (HTML supported)'),
-        }).shape,
-        annotations: WRITE_ANNOTATIONS,
+        }).strict(),
+        annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
     }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => sendChatMessage(c, args, signal)))));
+    server.registerTool('reply_to_message', {
+        description: 'Reply to a specific message in a chat, creating a threaded reply.',
+        inputSchema: z
+            .object({
+            chatId: z.string().describe('Chat ID'),
+            messageId: z.string().describe('ID of the chat message to reply to'),
+            content: z.string().describe('Reply content (HTML supported)'),
+        })
+            .strict(),
+        annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => replyToChatMessage(c, args, signal)))));
+    server.registerTool('search_messages', {
+        description: 'Search Teams chat and channel messages by keyword across conversations you can access.',
+        inputSchema: z
+            .object({
+            query: z.string().describe('Search text (keyword or phrase)'),
+            top: z.number().optional().describe('Max results to return (default: 10, max: 25)'),
+        })
+            .strict(),
+        annotations: READ_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => searchMessages(c, args, signal)))));
+    server.registerTool('find_user', {
+        description: 'Look up people in the organization by display name or email address. Use this to resolve a colleague to a user ID or email before creating a chat. Requires the User.ReadBasic.All Graph permission.',
+        inputSchema: z
+            .object({
+            query: z.string().describe('Display name or email address of the person to find'),
+        })
+            .strict(),
+        annotations: READ_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => {
+        const gate = await requireScopesGranted(['User.ReadBasic.All'], 'Looking up users');
+        if (gate)
+            return gate;
+        return successJson(await callGraph(extra, (c, signal) => findUser(c, args, signal)));
+    }));
+    server.registerTool('create_chat', {
+        description: 'Create a new 1:1 or group chat with one or more colleagues (by email address or user ID) and return the new chat ID, which can then be used with send_chat_message.',
+        inputSchema: z
+            .object({
+            members: z
+                .array(z.string())
+                .min(1)
+                .describe('Email addresses or user IDs of the other participants (one for a 1:1 chat, several for a group chat)'),
+            topic: z.string().optional().describe('Chat topic (group chats only)'),
+        })
+            .strict(),
+        annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => createChat(c, args, signal)))));
     server.registerTool('list_teams', {
         description: 'List Teams you are a member of.',
         inputSchema: z.object({}).shape,
@@ -54,10 +224,94 @@ export function registerTeamsTools(server) {
         }).shape,
         annotations: READ_ANNOTATIONS,
     }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => listChannels(c, args, signal)))));
+    server.registerTool('list_channel_messages', {
+        description: 'List recent messages in a Teams channel. Requires the ChannelMessage.Read.All Graph permission, which may need tenant admin approval.',
+        inputSchema: z.object({
+            teamId: z.string().describe('Team ID'),
+            channelId: z.string().describe('Channel ID'),
+            top: z.number().optional().describe('Max messages to return (default: 25, max: 50)'),
+        }).shape,
+        annotations: READ_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => {
+        const gate = await requireScopesGranted(['ChannelMessage.Read.All'], 'Reading channel messages');
+        if (gate)
+            return gate;
+        return successJson(await callGraph(extra, (c, signal) => listChannelMessages(c, args, signal)));
+    }));
+    server.registerTool('send_channel_message', {
+        description: 'Post a new message to a Teams channel. Requires the ChannelMessage.Send Graph permission, which may need tenant admin approval.',
+        inputSchema: z
+            .object({
+            teamId: z.string().describe('Team ID'),
+            channelId: z.string().describe('Channel ID'),
+            content: z.string().describe('Message content (HTML supported)'),
+        })
+            .strict(),
+        annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => {
+        const gate = await requireScopesGranted(['ChannelMessage.Send'], 'Posting channel messages');
+        if (gate)
+            return gate;
+        return successJson(await callGraph(extra, (c, signal) => sendChannelMessage(c, args, signal)));
+    }));
+    server.registerTool('reply_to_channel_message', {
+        description: 'Reply to an existing message in a Teams channel. Requires the ChannelMessage.Send Graph permission, which may need tenant admin approval.',
+        inputSchema: z
+            .object({
+            teamId: z.string().describe('Team ID'),
+            channelId: z.string().describe('Channel ID'),
+            messageId: z.string().describe('ID of the channel message to reply to'),
+            content: z.string().describe('Reply content (HTML supported)'),
+        })
+            .strict(),
+        annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => {
+        const gate = await requireScopesGranted(['ChannelMessage.Send'], 'Replying to channel messages');
+        if (gate)
+            return gate;
+        return successJson(await callGraph(extra, (c, signal) => replyToChannelMessage(c, args, signal)));
+    }));
     server.registerTool('get_presence', {
         description: 'Get your current presence status (available, busy, away, etc.).',
         inputSchema: z.object({}).shape,
         annotations: READ_ANNOTATIONS,
     }, withErrorHandling(async (args, extra) => successJson(await callGraph(extra, (c, signal) => getPresence(c, args, signal)))));
+    server.registerTool('get_user_presence', {
+        description: "Get a colleague's current presence status (available, busy, in a meeting, etc.). Requires the Presence.Read.All Graph permission, which may need tenant admin approval.",
+        inputSchema: z
+            .object({
+            userId: z.string().describe('User ID or email address of the colleague'),
+        })
+            .strict(),
+        annotations: READ_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => {
+        const gate = await requireScopesGranted(['Presence.Read.All'], "Reading a colleague's presence");
+        if (gate)
+            return gate;
+        return successJson(await callGraph(extra, (c, signal) => getUserPresence(c, args, signal)));
+    }));
+    server.registerTool('set_presence', {
+        description: 'Set your own presence status (e.g. Busy, DoNotDisturb, Away), optionally for a limited duration. Requires the Presence.ReadWrite Graph permission.',
+        inputSchema: z
+            .object({
+            availability: z
+                .enum(PRESENCE_AVAILABILITY_VALUES)
+                .describe('Presence availability to set'),
+            durationMinutes: z
+                .number()
+                .int()
+                .min(5)
+                .max(480)
+                .optional()
+                .describe('How long the status applies, in whole minutes (5-480). Omit to keep it until changed.'),
+        })
+            .strict(),
+        annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
+    }, withErrorHandling(async (args, extra) => {
+        const gate = await requireScopesGranted(['Presence.ReadWrite'], 'Setting presence');
+        if (gate)
+            return gate;
+        return successJson(await callGraph(extra, (c, signal) => setPresence(c, args, signal)));
+    }));
 }
 //# sourceMappingURL=tools.js.map

package/dist/untrusted-content.d.ts

@@ -21,13 +21,36 @@
 /**
  * Wrap a single untrusted string in an `<untrusted-content source="…">`
  * envelope, escaping any embedded close-tag variant so the envelope cannot be
- * broken out of. `undefined` passes through untouched. Idempotent for the same
- * `source`.
+ * broken out of.
+ *
+ * `undefined` and `null` are passed through untouched so callers can apply the wrapper
+ * uniformly to optional fields without branching.
+ *
+ * Idempotent: when `text` is already a properly-shaped envelope for the SAME
+ * `source` (starts with the matching OPEN tag, ends with CLOSE, and contains no
+ * internal close-tag variants), the original string is returned unchanged so
+ * `wrapUntrusted(wrapUntrusted(s, src), src) === wrapUntrusted(s, src)`.
  */
-export declare function wrapUntrusted(text: string | undefined, source: string): string | undefined;
+export declare function wrapUntrusted(text: string | null | undefined, source: string): string | undefined;
 /**
- * Recursively wrap every string value reachable inside `value`. Object keys are
- * structural and NOT wrapped; non-string leaves pass through unchanged.
+ * Strip one `<untrusted-content>` envelope from `text` if present, returning raw
+ * strings unchanged. This is intentionally one-layer and idempotent for already
+ * raw input so callers can accept either displayed wrapped content or manually
+ * authored content.
+ */
+export declare function unwrapUntrusted(text: string): string;
+/**
+ * Recursively wrap every string key and value reachable inside `value` (strings,
+ * arrays, plain-object property keys and values) in an `<untrusted-content>` envelope.
+ *
+ * Use this when a whole response blob is third-party data and you want to
+ * envelope it wholesale rather than enumerate fields. Non-string leaves (numbers,
+ * booleans, null) pass through unchanged.
  */
 export declare function wrapUntrustedJsonStrings<T>(value: T, source: string): T;
+/**
+ * Recursively unwrap every string key and value reachable inside `value`.
+ * Non-string leaves pass through unchanged.
+ */
+export declare function unwrapUntrustedJsonStrings<T>(value: T): T;
 //# sourceMappingURL=untrusted-content.d.ts.map

package/dist/untrusted-content.js

@@ -18,29 +18,45 @@
  * `untrusted-content` in any connector that talks to an external system; this
  * file (and the call sites that import from it) is what satisfies that gate.
  */
-const UNTRUSTED_CLOSE_TAG_VARIANT = /<\/untrusted-content[ \t]*>/gi;
+const UNTRUSTED_CLOSE_TAG_VARIANT = /<\/untrusted-content\s*>/gi;
 const ESCAPED_UNTRUSTED_CLOSE_TAG = '<\\/untrusted-content>';
+const UNTRUSTED_ENVELOPE = /^<untrusted-content source="[^"]*">([\s\S]*)<\/untrusted-content>$/;
 function escapeAttr(s) {
     return s.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 }
+/**
+ * Rewrite every `</untrusted-content>` variant (case-insensitive, optional
+ * whitespace before `>`) inside `s` to a benign textual form, so an attacker
+ * who controls the wrapped content cannot terminate the envelope early.
+ */
 function escapeCloseTagSentinels(s) {
     return s.replace(UNTRUSTED_CLOSE_TAG_VARIANT, ESCAPED_UNTRUSTED_CLOSE_TAG);
 }
+function unescapeCloseTagSentinels(s) {
+    return s.replaceAll(ESCAPED_UNTRUSTED_CLOSE_TAG, '</untrusted-content>');
+}
 /**
  * Wrap a single untrusted string in an `<untrusted-content source="…">`
  * envelope, escaping any embedded close-tag variant so the envelope cannot be
- * broken out of. `undefined` passes through untouched. Idempotent for the same
- * `source`.
+ * broken out of.
+ *
+ * `undefined` and `null` are passed through untouched so callers can apply the wrapper
+ * uniformly to optional fields without branching.
+ *
+ * Idempotent: when `text` is already a properly-shaped envelope for the SAME
+ * `source` (starts with the matching OPEN tag, ends with CLOSE, and contains no
+ * internal close-tag variants), the original string is returned unchanged so
+ * `wrapUntrusted(wrapUntrusted(s, src), src) === wrapUntrusted(s, src)`.
  */
 export function wrapUntrusted(text, source) {
-    if (text === undefined)
+    if (text === undefined || text === null)
         return undefined;
     const open = `<untrusted-content source="${escapeAttr(source)}">`;
     const close = '</untrusted-content>';
     if (text.startsWith(open) && text.endsWith(close) && text.length >= open.length + close.length) {
         const inner = text.slice(open.length, text.length - close.length);
         if (!UNTRUSTED_CLOSE_TAG_VARIANT.test(inner)) {
-            UNTRUSTED_CLOSE_TAG_VARIANT.lastIndex = 0;
+            UNTRUSTED_CLOSE_TAG_VARIANT.lastIndex = 0; // reset stateful /g regex
             return text;
         }
         UNTRUSTED_CLOSE_TAG_VARIANT.lastIndex = 0;
@@ -48,8 +64,24 @@ export function wrapUntrusted(text, source) {
     return `${open}${escapeCloseTagSentinels(text)}${close}`;
 }
 /**
- * Recursively wrap every string value reachable inside `value`. Object keys are
- * structural and NOT wrapped; non-string leaves pass through unchanged.
+ * Strip one `<untrusted-content>` envelope from `text` if present, returning raw
+ * strings unchanged. This is intentionally one-layer and idempotent for already
+ * raw input so callers can accept either displayed wrapped content or manually
+ * authored content.
+ */
+export function unwrapUntrusted(text) {
+    const match = UNTRUSTED_ENVELOPE.exec(text);
+    if (!match)
+        return text;
+    return unescapeCloseTagSentinels(match[1]);
+}
+/**
+ * Recursively wrap every string key and value reachable inside `value` (strings,
+ * arrays, plain-object property keys and values) in an `<untrusted-content>` envelope.
+ *
+ * Use this when a whole response blob is third-party data and you want to
+ * envelope it wholesale rather than enumerate fields. Non-string leaves (numbers,
+ * booleans, null) pass through unchanged.
  */
 export function wrapUntrustedJsonStrings(value, source) {
     if (typeof value === 'string') {
@@ -59,7 +91,29 @@ export function wrapUntrustedJsonStrings(value, source) {
         return value.map((item) => wrapUntrustedJsonStrings(item, source));
     }
     if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, wrapUntrustedJsonStrings(item, source)]));
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            wrapUntrusted(key, source) ?? key,
+            wrapUntrustedJsonStrings(item, source),
+        ]));
+    }
+    return value;
+}
+/**
+ * Recursively unwrap every string key and value reachable inside `value`.
+ * Non-string leaves pass through unchanged.
+ */
+export function unwrapUntrustedJsonStrings(value) {
+    if (typeof value === 'string') {
+        return unwrapUntrusted(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => unwrapUntrustedJsonStrings(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            unwrapUntrusted(key),
+            unwrapUntrustedJsonStrings(item),
+        ]));
     }
     return value;
 }

package/dist/utils.js

@@ -1,6 +1,13 @@
 import { MicrosoftRefreshDisabledError, detectAuthRequiredReason, formatGraphError, } from '@mindstone/mcp-server-microsoft-shared';
 import { TeamsBusinessError } from './teams.js';
 import { AUTH_TOOL_NAME, REQUEST_TIMEOUT_MS, getMsPackageId } from './types.js';
+import { wrapUntrusted } from './untrusted-content.js';
+// formatGraphError surfaces vendor-controlled response-body text
+// (`error.message` from the Graph JSON body). Envelope it so the model treats
+// it as data, not instructions (AGENTS.md security invariant #6).
+function formatGraphErrorForModel(err) {
+    return wrapUntrusted(formatGraphError(err), 'microsoft-teams:error:graph') ?? 'Unknown error';
+}
 export function abortableSignal(callerSignal) {
     const timeoutSignal = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
     if (!callerSignal)
@@ -140,7 +147,7 @@ export function buildErrorResponse(err) {
                     text: JSON.stringify({
                         ...buildAuthRequiredResponse(),
                         reason,
-                        error: formatGraphError(err),
+                        error: formatGraphErrorForModel(err),
                         package_id: getMsPackageId(),
                     }),
                 },
@@ -149,7 +156,7 @@ export function buildErrorResponse(err) {
         };
     }
     return errorResponse({
-        error: formatGraphError(err),
+        error: formatGraphErrorForModel(err),
         action_required: 'Retry the call. If it continues to fail, run authenticate_microsoft_account to refresh the connection.',
         next_step: AUTH_TOOL_NAME,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstone/mcp-server-microsoft-teams",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "mcpName": "io.github.mindstone/mcp-server-microsoft-teams",
   "description": "Microsoft 365 Teams via Graph: list chats, read/send messages, list teams/channels, presence.",
   "license": "FSL-1.1-MIT",
@@ -31,9 +31,12 @@
     "prepublishOnly": "npm run build && npm test",
     "watch": "tsc --watch",
     "start": "node dist/index.js",
+    "pretest": "npm run compose:template:check",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "compose:template": "node scripts/gen-compose-html.mjs",
+    "compose:template:check": "node scripts/gen-compose-html.mjs --check",
     "security:internal-refs": "node scripts/check-internal-refs.mjs"
   },
   "dependencies": {
@@ -42,6 +45,7 @@
     "zod": "^3.23.0"
   },
   "devDependencies": {
+    "@mindstone/mcp-app-compose": "file:../../packages/mcp-app-compose",
     "@mindstone/mcp-test-harness": "file:../../test-harness",
     "@types/node": "^22",
     "@vitest/coverage-v8": "^4.1.3",

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.mindstone/mcp-server-microsoft-teams",
   "title": "Microsoft 365 Teams",
   "description": "Microsoft 365 Teams via Graph: list chats, read/send messages, list teams/channels, presence.",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "repository": {
     "url": "https://github.com/mindstone/mcp-servers",
     "source": "github",
@@ -14,7 +14,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@mindstone/mcp-server-microsoft-teams",
-      "version": "0.1.2",
+      "version": "0.3.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"