epiphany-mcp-server.js

// epiphany-mcp-server.js
// MCP server implementation for Epiphany Booking API

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

const API_KEY = process.env.EPIPHANY_API_KEY;
const BASE_URL = 'https://epiphany.so/api/v1';

class EpiphanyMCPServer {
  constructor() {
    this.server = new Server(
      {
        name: 'epiphany-booking-server',
        version: '1.0.0',
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );

    this.setupHandlers();
  }

  async makeRequest(endpoint, method = 'GET', body = null) {
    const options = {
      method,
      headers: {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json',
      },
    };

    if (body) {
      options.body = JSON.stringify(body);
    }

    const response = await fetch(`${BASE_URL}${endpoint}`, options);

    if (!response.ok) {
      throw new Error(`API Error: ${response.status} ${response.statusText}`);
    }

    return response.json();
  }

  setupHandlers() {
    // List available tools
    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [
        {
          name: 'list_vsls',
          description: 'Get all VSLs to find VSL IDs for other operations',
          inputSchema: {
            type: 'object',
            properties: {},
            required: [],
          },
        },
        {
          name: 'get_vsl',
          description: 'Get detailed info about a specific VSL',
          inputSchema: {
            type: 'object',
            properties: {
              vsl_id: { type: 'string', description: 'The VSL ID (UUID format)' },
            },
            required: ['vsl_id'],
          },
        },
        {
          name: 'get_available_times',
          description: 'Check which time slots are available for booking on a specific date',
          inputSchema: {
            type: 'object',
            properties: {
              vsl_id: { type: 'string', description: 'The VSL ID' },
              date: { type: 'string', description: 'Date in YYYY-MM-DD format' },
            },
            required: ['vsl_id', 'date'],
          },
        },
        {
          name: 'create_booking',
          description: 'Create a new booking with optional auto-confirmation for instant Meet link',
          inputSchema: {
            type: 'object',
            properties: {
              vsl_id: { type: 'string', description: 'The VSL ID to book' },
              customer_name: { type: 'string', description: "Customer's full name" },
              customer_email: { type: 'string', description: "Customer's email" },
              customer_phone: { type: 'string', description: "Customer's phone (optional)" },
              booking_date: { type: 'string', description: 'Date in YYYY-MM-DD format' },
              booking_time: { type: 'string', description: "Time in 12-hour format (e.g., '10:00 AM')" },
              auto_confirm: { type: 'boolean', description: 'true = instant Meet link, false = pending', default: true },
            },
            required: ['vsl_id', 'customer_name', 'customer_email', 'booking_date', 'booking_time'],
          },
        },
        {
          name: 'list_bookings',
          description: 'Get all bookings across all VSLs',
          inputSchema: {
            type: 'object',
            properties: {},
            required: [],
          },
        },
        {
          name: 'get_booking',
          description: 'Get details of a specific booking by ID',
          inputSchema: {
            type: 'object',
            properties: {
              booking_id: { type: 'string', description: 'The booking ID (UUID format)' },
            },
            required: ['booking_id'],
          },
        },
        {
          name: 'get_waitlist',
          description: 'Get waitlist entries for a VSL with pagination',
          inputSchema: {
            type: 'object',
            properties: {
              vsl_id: { type: 'string', description: 'The VSL ID' },
              page: { type: 'integer', description: 'Page number (default: 1)', default: 1 },
              limit: { type: 'integer', description: 'Results per page (max: 50)', default: 50 },
            },
            required: ['vsl_id'],
          },
        },
      ],
    }));

    // Handle tool calls
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;

      try {
        switch (name) {
          case 'list_vsls':
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest('/vsls')) }] };

          case 'get_vsl':
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest(`/vsls/${args.vsl_id}`)) }] };

          case 'get_available_times':
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest(`/vsls/${args.vsl_id}/available-times?date=${args.date}`)) }] };

          case 'create_booking':
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest('/bookings', 'POST', args)) }] };

          case 'list_bookings':
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest('/bookings')) }] };

          case 'get_booking':
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest(`/bookings/${args.booking_id}`)) }] };

          case 'get_waitlist':
            const page = args.page || 1;
            const limit = args.limit || 50;
            return { content: [{ type: 'text', text: JSON.stringify(await this.makeRequest(`/vsls/${args.vsl_id}/waitlists?page=${page}&limit=${limit}`)) }] };

          default:
            throw new Error(`Unknown tool: ${name}`);
        }
      } catch (error) {
        return {
          content: [{ type: 'text', text: `Error: ${error.message}` }],
          isError: true,
        };
      }
    });
  }

  async run() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.error('Epiphany MCP Server running on stdio');
  }
}

const server = new EpiphanyMCPServer();
server.run().catch(console.error);