@meetbot/mcp 1.2.7 → 1.3.0

package/dist/mcp-server-streamable.js

@@ -16,48 +16,25 @@ export class MeetbotMCPStreamable {
     constructor() {
         this.server = new McpServer({
             name: 'meetbot-mcp',
-            version: '1.2.3',
+            version: '1.3.0',
             description: 'Meet.bot MCP Server for scheduling and booking',
         });
         this.setupToolHandlers();
+        this.setupPromptHandlers();
     }
+    /** Tool annotations for MCP/Smithery quality: audience, priority, lastModified per spec */
+    static TOOL_ANNOTATIONS = {
+        audience: ['user', 'assistant'],
+        priority: 0.8,
+        lastModified: '2025-03-05T00:00:00Z',
+    };
     setupToolHandlers() {
-        // Configure Meet.bot authentication tool
-        this.server.registerTool('configure_meetbot', {
-            title: 'Configure Meet.bot Authentication',
-            description: 'Configure Meet.bot API authentication (required before using other tools)',
-            inputSchema: {},
-        }, async (_, extra) => {
-            console.log('🔧 Configure Meetbot called for session:', extra.sessionId);
-            if (!extra.sessionId) {
-                throw new Error('Session ID is required');
-            }
-            // Check if client is already configured
-            const existingClient = this.clients.get(extra.sessionId);
-            if (existingClient) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '✅ Meet.bot client is already configured and ready to use.',
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '⚠️ Meet.bot client not configured. Please ensure the Authorization header is provided during connection.',
-                    },
-                ],
-            };
-        });
         // Get scheduling pages tool
         this.server.registerTool('get_scheduling_pages', {
             title: 'Get Scheduling Pages',
             description: 'Get all scheduling pages for the authenticated user',
             inputSchema: {},
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
         }, async (_, extra) => {
             if (!extra.sessionId) {
                 throw new Error('Session ID is required');
@@ -67,7 +44,7 @@ export class MeetbotMCPStreamable {
             }
             const client = this.clients.get(extra.sessionId);
             if (!client) {
-                throw new Error('Meet.bot client not configured. Please use configure_meetbot first.');
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
             }
             const pages = await client.getPages();
             return {
@@ -86,8 +63,9 @@ export class MeetbotMCPStreamable {
             title: 'Get Page Information',
             description: 'Get information about a specific scheduling page',
             inputSchema: {
-                page: z.string().describe('The URL of the scheduling page'),
+                page: z.string().describe('The URL of the scheduling page (e.g. https://meet.bot/your-page)'),
             },
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
         }, async ({ page }, extra) => {
             if (!extra.sessionId) {
                 throw new Error('Session ID is required');
@@ -97,7 +75,7 @@ export class MeetbotMCPStreamable {
             }
             const client = this.clients.get(extra.sessionId);
             if (!client) {
-                throw new Error('Meet.bot client not configured. Please use configure_meetbot first.');
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
             }
             if (!page) {
                 throw new Error('Page URL is required');
@@ -117,20 +95,21 @@ export class MeetbotMCPStreamable {
             title: 'Get Available Slots',
             description: 'Get available booking slots for a scheduling page',
             inputSchema: {
-                page: z.string().describe('The URL of the scheduling page'),
-                count: z.number().optional().describe('Maximum number of slots to return'),
-                start: z.string().optional().describe('Start date in YYYY-MM-DD format'),
-                end: z.string().optional().describe('End date in YYYY-MM-DD format'),
-                timezone: z.string().optional().describe('Timezone in IANA format (e.g., America/New_York)'),
-                booking_link: z.boolean().optional().describe('Include shareable booking links'),
+                page: z.string().describe('The URL of the scheduling page (e.g. https://meet.bot/your-page)'),
+                count: z.number().optional().describe('Maximum number of slots to return (defaults to server limit)'),
+                start: z.string().optional().describe('Start date for the range in YYYY-MM-DD format'),
+                end: z.string().optional().describe('End date for the range in YYYY-MM-DD format'),
+                timezone: z.string().optional().describe('IANA timezone for slot times (e.g. America/New_York, Europe/London)'),
+                booking_link: z.boolean().optional().describe('If true, include shareable booking links in the response'),
             },
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
         }, async ({ page, ...args }, extra) => {
             if (!extra.sessionId) {
                 throw new Error('Session ID is required');
             }
             const client = this.clients.get(extra.sessionId);
             if (!client) {
-                throw new Error('Meet.bot client not configured. Please use configure_meetbot first.');
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
             }
             if (!page) {
                 throw new Error('Page URL is required');
@@ -156,19 +135,20 @@ export class MeetbotMCPStreamable {
             title: 'Book Meeting',
             description: 'Book a new meeting slot',
             inputSchema: {
-                page: z.string().describe('The URL of the scheduling page'),
-                guest_email: z.string().describe('Email address of the guest'),
-                guest_name: z.string().describe('Name of the guest'),
-                notes: z.string().optional().describe('Additional notes for the meeting'),
-                start: z.string().describe('Start time in ISO 8601 format'),
+                page: z.string().describe('The URL of the scheduling page (e.g. https://meet.bot/your-page)'),
+                guest_email: z.string().describe('Email address of the guest (used for calendar invite and confirmation)'),
+                guest_name: z.string().describe('Full name of the guest'),
+                notes: z.string().optional().describe('Optional notes to include with the meeting (e.g. agenda, call details)'),
+                start: z.string().describe('Start time in ISO 8601 format (e.g. 2025-03-10T14:00:00Z); must be an available slot'),
             },
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
         }, async ({ page, guest_email, guest_name, notes, start }, extra) => {
             if (!extra.sessionId) {
                 throw new Error('Session ID is required');
             }
             const client = this.clients.get(extra.sessionId);
             if (!client) {
-                throw new Error('Meet.bot client not configured. Please use configure_meetbot first.');
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
             }
             if (!page || !guest_email || !guest_name || !start) {
                 throw new Error('Required parameters missing: page, guest_email, guest_name, start');
@@ -186,15 +166,16 @@ export class MeetbotMCPStreamable {
         // Health check tool
         this.server.registerTool('health_check', {
             title: 'Health Check',
-            description: 'Check if the Meet.bot API client is healthy',
+            description: 'Check if the Meet.bot API client is healthy and the Bearer token is valid',
             inputSchema: {},
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
         }, async (_, extra) => {
             if (!extra.sessionId) {
                 throw new Error('Session ID is required');
             }
             const client = this.clients.get(extra.sessionId);
             if (!client) {
-                throw new Error('Meet.bot client not configured. Please use configure_meetbot first.');
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
             }
             const isHealthy = await client.healthCheck();
             return {
@@ -208,6 +189,241 @@ export class MeetbotMCPStreamable {
                 ],
             };
         });
+        // List webhooks tool
+        this.server.registerTool('list_webhooks', {
+            title: 'List Webhooks',
+            description: "List the authenticated user's outbound booking webhooks (fired on booking_received, booking_rescheduled and booking_cancelled)",
+            inputSchema: {},
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
+        }, async (_, extra) => {
+            if (!extra.sessionId) {
+                throw new Error('Session ID is required');
+            }
+            const client = this.clients.get(extra.sessionId);
+            if (!client) {
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
+            }
+            const webhooks = await client.listWebhooks();
+            if (webhooks.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No webhooks configured yet. Use set_webhook to add one.' }],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Found ${webhooks.length} webhook(s):\n\n${webhooks
+                            .map((webhook) => `• #${webhook.id} ${webhook.description || '(unnamed)'} -> ${webhook.webhook_url}\n  coverage: ${webhook.coverage}, scope: ${webhook.scope}, active: ${webhook.is_active}`)
+                            .join('\n')}`,
+                    },
+                ],
+            };
+        });
+        // Set webhook tool (create or update)
+        this.server.registerTool('set_webhook', {
+            title: 'Set Webhook',
+            description: 'Create or update an outbound booking webhook. Omit id to create (webhook_url required); pass id to update. Meet.bot POSTs a JWT-signed (HS256) JSON payload to the URL on each booking event.',
+            inputSchema: {
+                id: z.number().optional().describe('Webhook id to update; omit to create a new one'),
+                webhook_url: z.string().optional().describe('HTTPS URL we POST booking events to (required when creating)'),
+                description: z.string().optional().describe('Optional label for the webhook'),
+                coverage: z.enum(['all', 'selected']).optional().describe("'all' (default) fires for every page including ones created later; 'selected' only for the pages in `pages`"),
+                scope: z.enum(['self', 'team']).optional().describe("'self' (default) your own pages; 'team' (team admins only) also fires for teammates' bookings"),
+                pages: z.array(z.number()).optional().describe("Page ids to cover when coverage='selected'"),
+                is_active: z.boolean().optional().describe('Whether the webhook is active (default true)'),
+            },
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
+        }, async (args, extra) => {
+            if (!extra.sessionId) {
+                throw new Error('Session ID is required');
+            }
+            const client = this.clients.get(extra.sessionId);
+            if (!client) {
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
+            }
+            const webhook = await client.setWebhook(args);
+            const secretLine = webhook.shared_secret
+                ? `\nShared secret (verify HS256 JWT signatures with this): ${webhook.shared_secret}`
+                : '';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Webhook saved (#${webhook.id}).\nURL: ${webhook.webhook_url}\nCoverage: ${webhook.coverage}, Scope: ${webhook.scope}, Active: ${webhook.is_active}${secretLine}`,
+                    },
+                ],
+            };
+        });
+        // Delete webhook tool
+        this.server.registerTool('delete_webhook', {
+            title: 'Delete Webhook',
+            description: "Delete one of the authenticated user's webhooks by id",
+            inputSchema: {
+                id: z.number().describe('The webhook id to delete'),
+            },
+            annotations: MeetbotMCPStreamable.TOOL_ANNOTATIONS,
+        }, async ({ id }, extra) => {
+            if (!extra.sessionId) {
+                throw new Error('Session ID is required');
+            }
+            const client = this.clients.get(extra.sessionId);
+            if (!client) {
+                throw new Error('Meet.bot client not configured. Provide an Authorization: Bearer <token> header when connecting to the MCP server.');
+            }
+            await client.deleteWebhook(id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Webhook #${id} deleted.`,
+                    },
+                ],
+            };
+        });
+    }
+    setupPromptHandlers() {
+        // 1. schedule_meeting – full flow: list pages → slots → book (confirm with user first)
+        this.server.registerPrompt('schedule_meeting', {
+            title: 'Schedule a meeting',
+            description: 'Get step-by-step instructions to schedule a meeting using this server. Use this when the user wants to book a meeting or check availability.',
+            argsSchema: {},
+        }, () => ({
+            description: 'Instructions for scheduling a meeting with Meet.bot',
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: 'I need to schedule a meeting. Please use the Meet.bot MCP tools to: 1) List my scheduling pages with get_scheduling_pages, 2) Get available slots for the chosen page with get_available_slots, and 3) Book the chosen slot with book_meeting (guest_email, guest_name, and start time required). Confirm the details with me before booking.',
+                    },
+                },
+            ],
+        }));
+        // 2. check_availability – "When is [person] next free?" – availability only, no booking
+        this.server.registerPrompt('check_availability', {
+            title: 'Check availability',
+            description: 'When is this person next free? Checks availability only; no booking. Use for pre-meeting research or answering "when are they free?"',
+            argsSchema: {
+                page: z.string().describe('The scheduling page URL (e.g. https://meet.bot/your-page)'),
+                days_ahead: z.string().optional().describe('Number of days to look ahead (default: 7)'),
+            },
+        }, (args) => {
+            const days = typeof args.days_ahead === 'string' && args.days_ahead !== '' ? parseInt(args.days_ahead, 10) : 7;
+            const start = new Date();
+            const end = new Date();
+            end.setDate(end.getDate() + days);
+            const startStr = start.toISOString().slice(0, 10);
+            const endStr = end.toISOString().slice(0, 10);
+            return {
+                description: 'Check when this person is next available; do not book.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Check availability only (no booking). Use get_available_slots with page "${args.page}", start "${startStr}", end "${endStr}", and a reasonable count (e.g. 10). Return when this person is next free. Do not book a meeting or collect guest details.`,
+                        },
+                    },
+                ],
+            };
+        });
+        // 3. book_for_guest – fast path when all details are already known
+        this.server.registerPrompt('book_for_guest', {
+            title: 'Book for guest',
+            description: 'Fast path when you already have all details. Books a meeting directly using the preferred time; useful when another system provides the slot.',
+            argsSchema: {
+                page: z.string().describe('The scheduling page URL'),
+                guest_name: z.string().describe('Full name of the guest'),
+                guest_email: z.string().describe('Email address of the guest'),
+                preferred_time: z.string().describe('Preferred start time in ISO 8601 format (e.g. 2025-03-10T14:00:00Z); should be an available slot'),
+            },
+        }, (args) => ({
+            description: 'Book a meeting with the given guest and time.',
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `Book a meeting now. Use book_meeting with: page "${args.page}", guest_name "${args.guest_name}", guest_email "${args.guest_email}", start "${args.preferred_time}". No need to discover slots first – book this exact time.`,
+                    },
+                },
+            ],
+        }));
+        // 4. share_booking_link – "Send [person] a link to book" – returns shareable links only
+        this.server.registerPrompt('share_booking_link', {
+            title: 'Share booking link',
+            description: 'Send the user a link to book. Returns shareable booking links; the guest picks their own slot. No booking is performed.',
+            argsSchema: {
+                page: z.string().describe('The scheduling page URL'),
+                count: z.string().optional().describe('Number of slot links to return (default: 3)'),
+            },
+        }, (args) => {
+            const count = typeof args.count === 'string' && args.count !== '' ? parseInt(args.count, 10) : 3;
+            return {
+                description: 'Get shareable booking links to send to the guest.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Get shareable booking links only (do not book). Use get_available_slots with page "${args.page}", booking_link: true, and count: ${count}. Return the first ${count} booking links formatted clearly so the user can copy or send them to their guest. The guest will choose their own slot.`,
+                        },
+                    },
+                ],
+            };
+        });
+        // 5. list_my_pages – starting point when the AI doesn't know which page to use
+        this.server.registerPrompt('list_my_pages', {
+            title: 'List my scheduling pages',
+            description: 'Starting point when you don\'t know which page to use. Lists the user\'s scheduling pages with a brief description of each.',
+            argsSchema: {},
+        }, () => ({
+            description: 'List the user’s scheduling pages.',
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: 'List my scheduling pages. Use get_scheduling_pages and present the results clearly: for each page show title, duration, and URL, with a brief description so I (or the user) can choose which page to use next.',
+                    },
+                },
+            ],
+        }));
+        // 6. suggest_times – offer N options for the user to pick
+        this.server.registerPrompt('suggest_times', {
+            title: 'Suggest times',
+            description: 'Offer the user some options. Returns a clean list of available slots for them to pick from; no booking until they choose.',
+            argsSchema: {
+                page: z.string().describe('The scheduling page URL'),
+                count: z.string().optional().describe('Number of slot options to return (default: 3)'),
+                timezone: z.string().optional().describe('IANA timezone for displaying times (e.g. America/New_York)'),
+                start_date: z.string().optional().describe('Start of range in YYYY-MM-DD format'),
+                end_date: z.string().optional().describe('End of range in YYYY-MM-DD format'),
+            },
+        }, (args) => {
+            const count = typeof args.count === 'string' && args.count !== '' ? parseInt(args.count, 10) : 3;
+            const parts = [`Use get_available_slots with page "${args.page}" and count: ${count}.`];
+            if (args.timezone)
+                parts.push(`Use timezone "${args.timezone}" for display.`);
+            if (args.start_date)
+                parts.push(`Restrict to start date ${args.start_date}.`);
+            if (args.end_date)
+                parts.push(`Restrict to end date ${args.end_date}.`);
+            parts.push('Format the slots as a clean, numbered list for the user to pick one. Do not book until they choose.');
+            return {
+                description: 'Present available times for the user to choose from.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: parts.join(' '),
+                        },
+                    },
+                ],
+            };
+        });
     }
     /**
      * Create Express app with MCP endpoints
@@ -227,6 +443,202 @@ export class MeetbotMCPStreamable {
             }
             next();
         });
+        // MCP server card (well-known discovery) – structured for Smithery Tool Quality (annotations, param descriptions, title)
+        const toolAnnotations = {
+            audience: ['user', 'assistant'],
+            priority: 0.8,
+            lastModified: '2025-03-05T00:00:00Z',
+        };
+        const serverCard = {
+            serverInfo: {
+                name: 'meetbot-mcp',
+                version: '1.3.0',
+                description: 'Meet.bot MCP Server for scheduling and booking. Lets AI agents check availability, get scheduling page info, and book meetings on your behalf.',
+            },
+            authentication: {
+                required: true,
+                schemes: ['bearer'],
+                instructions: 'Provide your Meet.bot API key as a Bearer token in the Authorization header: Authorization: Bearer <your-api-key>',
+            },
+            tools: [
+                {
+                    name: 'get_scheduling_pages',
+                    title: 'Get Scheduling Pages',
+                    description: 'Get all scheduling pages for the authenticated user',
+                    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'get_page_info',
+                    title: 'Get Page Information',
+                    description: 'Get information about a specific scheduling page',
+                    inputSchema: {
+                        type: 'object',
+                        description: 'Parameters for fetching a single scheduling page.',
+                        properties: {
+                            page: { type: 'string', description: 'The URL of the scheduling page (e.g. https://meet.bot/your-page)' },
+                        },
+                        required: ['page'],
+                        additionalProperties: false,
+                    },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'get_available_slots',
+                    title: 'Get Available Slots',
+                    description: 'Get available booking slots for a scheduling page',
+                    inputSchema: {
+                        type: 'object',
+                        description: 'Parameters for querying available slots (optional filters for count, date range, timezone, and booking links).',
+                        properties: {
+                            page: { type: 'string', description: 'The URL of the scheduling page (e.g. https://meet.bot/your-page)' },
+                            count: { type: 'number', description: 'Maximum number of slots to return (defaults to server limit)' },
+                            start: { type: 'string', description: 'Start date for the range in YYYY-MM-DD format' },
+                            end: { type: 'string', description: 'End date for the range in YYYY-MM-DD format' },
+                            timezone: { type: 'string', description: 'IANA timezone for slot times (e.g. America/New_York, Europe/London)' },
+                            booking_link: { type: 'boolean', description: 'If true, include shareable booking links in the response' },
+                        },
+                        required: ['page'],
+                        additionalProperties: false,
+                    },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'book_meeting',
+                    title: 'Book Meeting',
+                    description: 'Book a new meeting slot',
+                    inputSchema: {
+                        type: 'object',
+                        description: 'Parameters for booking a meeting (guest details and chosen slot).',
+                        properties: {
+                            page: { type: 'string', description: 'The URL of the scheduling page (e.g. https://meet.bot/your-page)' },
+                            guest_email: { type: 'string', description: 'Email address of the guest (used for calendar invite and confirmation)' },
+                            guest_name: { type: 'string', description: 'Full name of the guest' },
+                            notes: { type: 'string', description: 'Optional notes to include with the meeting (e.g. agenda, call details)' },
+                            start: { type: 'string', description: 'Start time in ISO 8601 format (e.g. 2025-03-10T14:00:00Z); must be an available slot' },
+                        },
+                        required: ['page', 'guest_email', 'guest_name', 'start'],
+                        additionalProperties: false,
+                    },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'health_check',
+                    title: 'Health Check',
+                    description: 'Check if the Meet.bot API client is healthy and the Bearer token is valid',
+                    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'list_webhooks',
+                    title: 'List Webhooks',
+                    description: "List the authenticated user's outbound booking webhooks (fired on booking_received, booking_rescheduled and booking_cancelled)",
+                    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'set_webhook',
+                    title: 'Set Webhook',
+                    description: 'Create or update an outbound booking webhook. Omit id to create (webhook_url required); pass id to update. Meet.bot POSTs a JWT-signed (HS256) JSON payload to the URL on each booking event.',
+                    inputSchema: {
+                        type: 'object',
+                        description: 'Parameters for creating or updating a booking webhook.',
+                        properties: {
+                            id: { type: 'number', description: 'Webhook id to update; omit to create a new one' },
+                            webhook_url: { type: 'string', description: 'HTTPS URL we POST booking events to (required when creating)' },
+                            description: { type: 'string', description: 'Optional label for the webhook' },
+                            coverage: { type: 'string', enum: ['all', 'selected'], description: "'all' (default) fires for every page including ones created later; 'selected' only for the pages in `pages`" },
+                            scope: { type: 'string', enum: ['self', 'team'], description: "'self' (default) your own pages; 'team' (team admins only) also fires for teammates' bookings" },
+                            pages: { type: 'array', items: { type: 'number' }, description: "Page ids to cover when coverage='selected'" },
+                            is_active: { type: 'boolean', description: 'Whether the webhook is active (default true)' },
+                        },
+                        additionalProperties: false,
+                    },
+                    annotations: toolAnnotations,
+                },
+                {
+                    name: 'delete_webhook',
+                    title: 'Delete Webhook',
+                    description: "Delete one of the authenticated user's webhooks by id",
+                    inputSchema: {
+                        type: 'object',
+                        description: 'Parameters for deleting a webhook.',
+                        properties: {
+                            id: { type: 'number', description: 'The webhook id to delete' },
+                        },
+                        required: ['id'],
+                        additionalProperties: false,
+                    },
+                    annotations: toolAnnotations,
+                },
+            ],
+            prompts: [
+                {
+                    name: 'schedule_meeting',
+                    title: 'Schedule a meeting',
+                    description: 'Get step-by-step instructions to schedule a meeting using this server. Use this when the user wants to book a meeting or check availability.',
+                    arguments: [],
+                },
+                {
+                    name: 'check_availability',
+                    title: 'Check availability',
+                    description: 'When is this person next free? Checks availability only; no booking. Use for pre-meeting research or answering "when are they free?"',
+                    arguments: [
+                        { name: 'page', description: 'The scheduling page URL (e.g. https://meet.bot/your-page)', required: true },
+                        { name: 'days_ahead', description: 'Number of days to look ahead (default: 7)', required: false },
+                    ],
+                },
+                {
+                    name: 'book_for_guest',
+                    title: 'Book for guest',
+                    description: 'Fast path when you already have all details. Books a meeting directly using the preferred time; useful when another system provides the slot.',
+                    arguments: [
+                        { name: 'page', description: 'The scheduling page URL', required: true },
+                        { name: 'guest_name', description: 'Full name of the guest', required: true },
+                        { name: 'guest_email', description: 'Email address of the guest', required: true },
+                        { name: 'preferred_time', description: 'Preferred start time in ISO 8601 format (e.g. 2025-03-10T14:00:00Z); should be an available slot', required: true },
+                    ],
+                },
+                {
+                    name: 'share_booking_link',
+                    title: 'Share booking link',
+                    description: 'Send the user a link to book. Returns shareable booking links; the guest picks their own slot. No booking is performed.',
+                    arguments: [
+                        { name: 'page', description: 'The scheduling page URL', required: true },
+                        { name: 'count', description: 'Number of slot links to return (default: 3)', required: false },
+                    ],
+                },
+                {
+                    name: 'list_my_pages',
+                    title: 'List my scheduling pages',
+                    description: "Starting point when you don't know which page to use. Lists the user's scheduling pages with a brief description of each.",
+                    arguments: [],
+                },
+                {
+                    name: 'suggest_times',
+                    title: 'Suggest times',
+                    description: 'Offer the user some options. Returns a clean list of available slots for them to pick from; no booking until they choose.',
+                    arguments: [
+                        { name: 'page', description: 'The scheduling page URL', required: true },
+                        { name: 'count', description: 'Number of slot options to return (default: 3)', required: false },
+                        { name: 'timezone', description: 'IANA timezone for displaying times (e.g. America/New_York)', required: false },
+                        { name: 'start_date', description: 'Start of range in YYYY-MM-DD format', required: false },
+                        { name: 'end_date', description: 'End of range in YYYY-MM-DD format', required: false },
+                    ],
+                },
+            ],
+        };
+        app.get('/.well-known/mcp/server-card.json', (_req, res) => {
+            res.type('application/json').json(serverCard);
+        });
+        // Glama directory ownership claim — Glama verifies the maintainer email
+        // against the claiming account, then unlocks listing metadata/control.
+        app.get('/.well-known/glama.json', (_req, res) => {
+            res.type('application/json').json({
+                $schema: 'https://glama.ai/mcp/schemas/glama.json',
+                maintainers: [{ email: 'vincent@meet.bot' }],
+            });
+        });
         // MCP POST endpoint (naked path for dedicated MCP subdomain)
         app.post('/', async (req, res) => {
             const sessionId = req.headers['mcp-session-id'];