@adrata/adrata-mcp 1.0.0

package/tools/scheduling.js

@@ -0,0 +1,322 @@
+/**
+ * Demo Scheduling Module — Cal.com Integration
+ *
+ * Free tier: get_demo_availability, schedule_demo (no auth required)
+ * Enterprise tier: schedule_meeting (creates meeting on user's connected calendar)
+ *
+ * Environment:
+ *   CAL_COM_API_KEY  — Cal.com API key for fetching availability and creating bookings
+ *
+ * Fallback: if Cal.com API is unavailable, returns a direct booking link URL.
+ */
+
+const CAL_COM_API_KEY = process.env.CAL_COM_API_KEY || '';
+const CAL_COM_BASE = 'https://api.cal.com/v1';
+const CAL_COM_BOOKING_LINK = 'https://cal.com/ross-adrata/demo';
+const DEFAULT_EVENT_TYPE_ID = process.env.CAL_COM_EVENT_TYPE_ID || '';
+const DEMO_DURATION_MINUTES = 30;
+
+// ---------------------------------------------------------------------------
+// Time zone detection
+// ---------------------------------------------------------------------------
+
+function detectTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return 'America/Los_Angeles';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Cal.com API helpers
+// ---------------------------------------------------------------------------
+
+async function calApi(method, path, { params, body } = {}) {
+  const url = new URL(path, CAL_COM_BASE);
+  url.searchParams.set('apiKey', CAL_COM_API_KEY);
+
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v != null && v !== '') url.searchParams.set(k, String(v));
+    }
+  }
+
+  const res = await fetch(url.toString(), {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  const text = await res.text();
+  let data;
+  try { data = JSON.parse(text); } catch { data = { raw: text }; }
+
+  if (!res.ok) {
+    throw new Error(`Cal.com ${method} ${path} -> ${res.status}: ${JSON.stringify(data).slice(0, 300)}`);
+  }
+  return data;
+}
+
+/**
+ * Check whether the Cal.com API is reachable and configured.
+ */
+function isCalComConfigured() {
+  return CAL_COM_API_KEY.length > 0;
+}
+
+// ---------------------------------------------------------------------------
+// get_demo_availability
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch next available demo slots from Cal.com.
+ * Returns up to 5 slots with date, time, and duration.
+ * Falls back to booking link if API is unavailable.
+ *
+ * @param {string} [timezone] - IANA timezone string
+ * @returns {object} MCP response with availability data
+ */
+export async function getDemoAvailability(timezone) {
+  const tz = timezone || detectTimezone();
+
+  if (!isCalComConfigured()) {
+    return {
+      available: false,
+      fallback: true,
+      bookingLink: CAL_COM_BOOKING_LINK,
+      timezone: tz,
+      message: `Cal.com API not configured. Book a demo directly: ${CAL_COM_BOOKING_LINK}`,
+    };
+  }
+
+  try {
+    // Cal.com v1: GET /availability with dateFrom/dateTo
+    const now = new Date();
+    const dateFrom = now.toISOString().split('T')[0];
+    const dateTo = new Date(now.getTime() + 14 * 86400000).toISOString().split('T')[0];
+
+    const data = await calApi('GET', '/availability', {
+      params: {
+        eventTypeId: DEFAULT_EVENT_TYPE_ID || undefined,
+        dateFrom,
+        dateTo,
+        timeZone: tz,
+      },
+    });
+
+    // Cal.com returns { slots: { "2024-01-15": ["09:00", "09:30", ...] } }
+    // or { availability: [...] } depending on endpoint version
+    const slots = [];
+
+    if (data.slots && typeof data.slots === 'object') {
+      for (const [date, times] of Object.entries(data.slots)) {
+        if (!Array.isArray(times)) continue;
+        for (const time of times) {
+          const timeStr = typeof time === 'string' ? time : time?.time;
+          if (timeStr) {
+            slots.push({
+              date,
+              time: timeStr,
+              duration: `${DEMO_DURATION_MINUTES} min`,
+            });
+          }
+          if (slots.length >= 5) break;
+        }
+        if (slots.length >= 5) break;
+      }
+    } else if (Array.isArray(data.availability)) {
+      for (const slot of data.availability) {
+        slots.push({
+          date: slot.date || slot.start?.split('T')[0],
+          time: slot.time || slot.start?.split('T')[1]?.slice(0, 5),
+          duration: `${DEMO_DURATION_MINUTES} min`,
+        });
+        if (slots.length >= 5) break;
+      }
+    }
+
+    if (slots.length === 0) {
+      return {
+        available: false,
+        fallback: true,
+        bookingLink: CAL_COM_BOOKING_LINK,
+        timezone: tz,
+        message: `No available slots in the next 14 days. Book directly: ${CAL_COM_BOOKING_LINK}`,
+      };
+    }
+
+    return {
+      available: true,
+      slots,
+      timezone: tz,
+      bookingLink: CAL_COM_BOOKING_LINK,
+      note: 'Reply with a slot number or date/time to book.',
+    };
+  } catch (err) {
+    return {
+      available: false,
+      fallback: true,
+      bookingLink: CAL_COM_BOOKING_LINK,
+      timezone: tz,
+      message: `Could not reach Cal.com API. Book a demo directly: ${CAL_COM_BOOKING_LINK}`,
+      error: err.message,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// schedule_demo
+// ---------------------------------------------------------------------------
+
+/**
+ * Book a demo meeting via Cal.com.
+ * Falls back to booking link if API is unavailable.
+ *
+ * @param {string} date - Date in YYYY-MM-DD format
+ * @param {string} time - Time in HH:MM format (24h)
+ * @param {string} name - Attendee full name
+ * @param {string} email - Attendee email address
+ * @param {string} [company] - Attendee company name
+ * @param {string} [timezone] - IANA timezone string
+ * @returns {object} MCP response with booking confirmation or fallback
+ */
+export async function scheduleDemo({ date, time, name, email, company, timezone }) {
+  const tz = timezone || detectTimezone();
+
+  if (!isCalComConfigured()) {
+    return {
+      booked: false,
+      fallback: true,
+      bookingLink: CAL_COM_BOOKING_LINK,
+      message: `Cal.com API not configured. Book directly: ${CAL_COM_BOOKING_LINK}`,
+      attendee: { name, email, company },
+    };
+  }
+
+  try {
+    // Construct ISO start time
+    const startTime = `${date}T${time}:00`;
+
+    const bookingPayload = {
+      eventTypeId: DEFAULT_EVENT_TYPE_ID ? Number(DEFAULT_EVENT_TYPE_ID) : undefined,
+      start: startTime,
+      end: undefined, // Cal.com computes from event type duration
+      responses: {
+        name,
+        email,
+        ...(company ? { company } : {}),
+      },
+      timeZone: tz,
+      language: 'en',
+      metadata: {
+        source: 'adrata-mcp',
+      },
+    };
+
+    // Clean undefined keys
+    Object.keys(bookingPayload).forEach(k => {
+      if (bookingPayload[k] === undefined) delete bookingPayload[k];
+    });
+
+    const data = await calApi('POST', '/bookings', { body: bookingPayload });
+
+    return {
+      booked: true,
+      booking: {
+        id: data.id || data.uid,
+        title: data.title || 'Adrata Demo',
+        startTime: data.startTime || data.start || startTime,
+        endTime: data.endTime || data.end,
+        attendee: { name, email, company },
+        timezone: tz,
+        meetingUrl: data.metadata?.videoCallUrl || data.meetingUrl || null,
+      },
+      message: `Demo booked for ${name} (${email}) on ${date} at ${time} ${tz}. A confirmation email has been sent.`,
+    };
+  } catch (err) {
+    return {
+      booked: false,
+      fallback: true,
+      bookingLink: CAL_COM_BOOKING_LINK,
+      message: `Could not create booking via Cal.com. Book directly: ${CAL_COM_BOOKING_LINK}`,
+      error: err.message,
+      attendee: { name, email, company },
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// schedule_meeting (enterprise)
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a meeting on the user's connected calendar via the Rust API.
+ * Enterprise tier only — requires OAuth connection.
+ *
+ * @param {object} params - Meeting parameters
+ * @param {Function} api - The server's api() helper
+ * @returns {object} MCP response with meeting details
+ */
+export async function scheduleMeeting({ title, eventId, date, time, duration, attendees, description, timezone, dryRun, reason, confirmationToken }, api) {
+  const tz = timezone || detectTimezone();
+
+  const startTime = `${date}T${time}:00`;
+  const durationMinutes = duration || 30;
+
+  // Calculate end time
+  const startDate = new Date(`${startTime}`);
+  const endDate = new Date(startDate.getTime() + durationMinutes * 60000);
+  const endTime = endDate.toISOString();
+
+  const meetingBody = {
+    ...(eventId ? { eventId } : {}),
+    title: title || 'Meeting',
+    startTime,
+    endTime,
+    duration: durationMinutes,
+    timezone: tz,
+    description: description || '',
+    attendees: Array.isArray(attendees) ? attendees : (attendees ? [attendees] : []),
+  };
+
+  const data = await api('POST', '/api/v1/ai-crm-tools/execute', {
+    body: {
+      toolName: 'schedule_meeting',
+      arguments: meetingBody,
+      dryRun: dryRun ?? true,
+      reason,
+      confirmationToken,
+    },
+  });
+
+  const result = data?.data || data;
+  const scheduled = result?.data || result;
+  const preview = scheduled?.dryRun === true;
+  const needsConfirmation = Boolean(scheduled?.confirmationToken);
+
+  return {
+    created: Boolean(scheduled?.id),
+    dryRun: preview,
+    confirmationRequired: needsConfirmation,
+    confirmationToken: scheduled?.confirmationToken,
+    meeting: {
+      id: scheduled?.id,
+      title: meetingBody.title,
+      startTime,
+      endTime,
+      duration: durationMinutes,
+      timezone: tz,
+      attendees: meetingBody.attendees,
+      meetingUrl: scheduled?.meetingUrl || null,
+      calendarSyncStatus: scheduled?.calendarSyncStatus || null,
+      invitationDeliveryStatus: scheduled?.invitationDeliveryStatus || null,
+      invitesSent: scheduled?.invitesSent === true,
+    },
+    message: scheduled?.message || (preview
+      ? `Meeting "${meetingBody.title}" previewed for ${date} at ${time} ${tz}; nothing was written.`
+      : needsConfirmation
+        ? 'Approval captured. Re-run with the returned confirmation token to create and queue the event.'
+        : `Meeting "${meetingBody.title}" was submitted. Check calendarSyncStatus before claiming invitations were sent.`),
+  };
+}