mcp-icloud 2.1.1

package/calendar/caldav-client.js

@@ -0,0 +1,320 @@
+/**
+ * CalDAV client for iCloud Calendar
+ */
+
+const { DAVClient } = require('tsdav');
+const ICAL = require('ical.js');
+const config = require('../config');
+const { getCredentials } = require('../auth');
+
+let cachedClient = null;
+
+/**
+ * Get or create CalDAV client
+ */
+async function getClient() {
+  if (cachedClient) {
+    return cachedClient;
+  }
+
+  const creds = getCredentials();
+
+  const client = new DAVClient({
+    serverUrl: config.CALDAV.SERVER_URL,
+    credentials: {
+      username: creds.email,
+      password: creds.password
+    },
+    authMethod: 'Basic',
+    defaultAccountType: 'caldav'
+  });
+
+  try {
+    await client.login();
+    cachedClient = client;
+    return client;
+  } catch (error) {
+    if (error.message?.includes('401') || error.message?.includes('auth')) {
+      throw new Error('UNAUTHORIZED');
+    }
+    throw error;
+  }
+}
+
+/**
+ * Clear cached client (for re-auth)
+ */
+function clearClient() {
+  cachedClient = null;
+}
+
+/**
+ * Get all calendars
+ */
+async function getCalendars() {
+  const client = await getClient();
+  const calendars = await client.fetchCalendars();
+  return calendars.map(cal => ({
+    url: cal.url,
+    displayName: cal.displayName || 'Unnamed Calendar',
+    ctag: cal.ctag,
+    syncToken: cal.syncToken
+  }));
+}
+
+/**
+ * Parse iCalendar event to simple object
+ */
+function parseEvent(icalData, url) {
+  try {
+    const jcalData = ICAL.parse(icalData);
+    const comp = new ICAL.Component(jcalData);
+    const vevent = comp.getFirstSubcomponent('vevent');
+
+    if (!vevent) return null;
+
+    const event = new ICAL.Event(vevent);
+
+    return {
+      url,
+      uid: event.uid,
+      summary: event.summary || '(No title)',
+      description: event.description || '',
+      location: event.location || '',
+      start: event.startDate?.toJSDate(),
+      end: event.endDate?.toJSDate(),
+      isAllDay: event.startDate?.isDate || false,
+      organizer: vevent.getFirstPropertyValue('organizer'),
+      attendees: vevent.getAllProperties('attendee').map(a => a.getFirstValue()),
+      status: event.status,
+      created: vevent.getFirstPropertyValue('created')?.toJSDate(),
+      lastModified: vevent.getFirstPropertyValue('last-modified')?.toJSDate()
+    };
+  } catch (error) {
+    console.error('Error parsing event:', error.message);
+    return null;
+  }
+}
+
+/**
+ * List events from all calendars
+ */
+async function listEvents(count = 25, daysAhead = 30) {
+  const client = await getClient();
+  const calendars = await client.fetchCalendars();
+
+  const now = new Date();
+  const endDate = new Date();
+  endDate.setDate(endDate.getDate() + daysAhead);
+
+  const allEvents = [];
+
+  for (const calendar of calendars) {
+    try {
+      const calendarObjects = await client.fetchCalendarObjects({
+        calendar,
+        timeRange: {
+          start: now.toISOString(),
+          end: endDate.toISOString()
+        }
+      });
+
+      for (const obj of calendarObjects) {
+        const event = parseEvent(obj.data, obj.url);
+        if (event) {
+          event.calendarName = calendar.displayName || 'Calendar';
+          allEvents.push(event);
+        }
+      }
+    } catch (error) {
+      console.error(`Error fetching from calendar ${calendar.displayName}:`, error.message);
+    }
+  }
+
+  // Sort by start date
+  allEvents.sort((a, b) => (a.start || 0) - (b.start || 0));
+
+  return allEvents.slice(0, count);
+}
+
+/**
+ * Create a new event
+ */
+async function createEvent({ summary, start, end, description, location, calendarUrl }) {
+  const client = await getClient();
+
+  // Get calendars if URL not provided
+  let targetCalendar;
+  if (calendarUrl) {
+    const calendars = await client.fetchCalendars();
+    targetCalendar = calendars.find(c => c.url === calendarUrl);
+  }
+
+  if (!targetCalendar) {
+    const calendars = await client.fetchCalendars();
+    targetCalendar = calendars[0]; // Use first calendar
+  }
+
+  if (!targetCalendar) {
+    throw new Error('No calendar found');
+  }
+
+  // Create iCalendar data
+  const uid = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}@icloud-mcp`;
+
+  const startDate = new Date(start);
+  const endDate = new Date(end);
+
+  const icalData = `BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//iCloud MCP//EN
+BEGIN:VEVENT
+UID:${uid}
+DTSTAMP:${formatICalDate(new Date())}
+DTSTART:${formatICalDate(startDate)}
+DTEND:${formatICalDate(endDate)}
+SUMMARY:${escapeICalText(summary)}${description ? `\nDESCRIPTION:${escapeICalText(description)}` : ''}${location ? `\nLOCATION:${escapeICalText(location)}` : ''}
+END:VEVENT
+END:VCALENDAR`;
+
+  const result = await client.createCalendarObject({
+    calendar: targetCalendar,
+    filename: `${uid}.ics`,
+    iCalString: icalData
+  });
+
+  return {
+    success: true,
+    uid,
+    url: result?.url,
+    calendar: targetCalendar.displayName
+  };
+}
+
+/**
+ * Rewrite individual properties of an existing VEVENT.
+ *
+ * Deliberately a line-level edit rather than rebuilding the iCalendar from
+ * scratch: a rebuild would silently drop RRULE, ATTENDEE, VALARM and any other
+ * property this server does not model, which on a real calendar means losing
+ * recurrence and invitees on every edit.
+ *
+ * @param {string} ical - Existing iCalendar text
+ * @param {Object} changes - Properties to set; undefined values are left alone
+ * @returns {string} - Updated iCalendar text
+ */
+function applyICalChanges(ical, { summary, start, end, description, location }) {
+  const updates = [];
+  if (summary !== undefined) updates.push(['SUMMARY', escapeICalText(summary)]);
+  if (start !== undefined) updates.push(['DTSTART', formatICalDate(new Date(start))]);
+  if (end !== undefined) updates.push(['DTEND', formatICalDate(new Date(end))]);
+  if (description !== undefined) updates.push(['DESCRIPTION', escapeICalText(description)]);
+  if (location !== undefined) updates.push(['LOCATION', escapeICalText(location)]);
+  updates.push(['DTSTAMP', formatICalDate(new Date())]);
+
+  const lines = ical.split(/\r?\n/);
+
+  for (const [key, value] of updates) {
+    // A property may carry parameters, e.g. DTSTART;TZID=Europe/Madrid:...
+    const idx = lines.findIndex(l => {
+      const upper = l.toUpperCase();
+      return upper.startsWith(key + ':') || upper.startsWith(key + ';');
+    });
+
+    if (idx !== -1) {
+      lines[idx] = `${key}:${value}`;
+    } else {
+      const endIdx = lines.findIndex(l => l.toUpperCase().startsWith('END:VEVENT'));
+      lines.splice(endIdx === -1 ? lines.length : endIdx, 0, `${key}:${value}`);
+    }
+  }
+
+  return lines.join('\r\n');
+}
+
+/**
+ * Update an existing event, preserving every property not being changed.
+ */
+async function updateEvent(eventUrl, changes) {
+  const client = await getClient();
+  const calendars = await client.fetchCalendars();
+
+  let existing = null;
+  for (const calendar of calendars) {
+    try {
+      const objects = await client.fetchCalendarObjects({
+        calendar,
+        objectUrls: [eventUrl]
+      });
+      if (objects && objects.length && objects[0].data) {
+        existing = objects[0];
+        break;
+      }
+    } catch (error) {
+      // Wrong calendar for this URL; keep looking.
+    }
+  }
+
+  if (!existing) {
+    throw new Error(`Event not found: ${eventUrl}`);
+  }
+
+  const updated = applyICalChanges(existing.data, changes);
+
+  await client.updateCalendarObject({
+    calendarObject: {
+      url: eventUrl,
+      data: updated,
+      etag: existing.etag || ''
+    }
+  });
+
+  return { success: true, url: eventUrl };
+}
+
+/**
+ * Delete an event
+ */
+async function deleteEvent(eventUrl) {
+  const client = await getClient();
+
+  await client.deleteCalendarObject({
+    calendarObject: {
+      url: eventUrl,
+      etag: '' // Will be fetched
+    }
+  });
+
+  return { success: true };
+}
+
+/**
+ * Format date for iCalendar
+ */
+function formatICalDate(date) {
+  return date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
+}
+
+/**
+ * Escape text for iCalendar
+ */
+function escapeICalText(text) {
+  if (!text) return '';
+  return text
+    .replace(/\\/g, '\\\\')
+    .replace(/;/g, '\\;')
+    .replace(/,/g, '\\,')
+    .replace(/\n/g, '\\n');
+}
+
+module.exports = {
+  getClient,
+  clearClient,
+  getCalendars,
+  listEvents,
+  createEvent,
+  updateEvent,
+  deleteEvent,
+  parseEvent,
+  applyICalChanges
+};

package/calendar/index.js

@@ -0,0 +1,252 @@
+/**
+ * Calendar module for iCloud MCP
+ * Provides calendar tools via CalDAV
+ */
+
+const { z } = require('zod');
+const cloudClient = require('./caldav-client');
+const localClient = require('./local-client');
+const { isLocalMode } = require('../mode');
+const { formatSuccess, formatError, withErrorHandler } = require('../utils/error-handler');
+const { listOutput, listResult } = require('../utils/schemas');
+const { formatDate } = require('../utils/date-utils');
+const config = require('../config');
+
+/**
+ * Normalize an event to one shape regardless of mode.
+ *
+ * Local (Calendar.app) keys events by UID and returns ISO strings; cloud
+ * (CalDAV) keys them by URL and returns Date objects. Everything downstream
+ * sees `ref` (the handle you pass back to update/delete), `start`/`end` as
+ * Dates, and `calendarName`.
+ */
+function normalizeEvent(event, local) {
+  if (!local) return { ...event, ref: event.url };
+
+  return {
+    summary: event.summary,
+    start: event.startDate ? new Date(event.startDate) : null,
+    end: event.endDate ? new Date(event.endDate) : null,
+    location: event.location || '',
+    calendarName: event.calendar,
+    isAllDay: false,
+    ref: event.id,
+    uid: event.id
+  };
+}
+
+/**
+ * Normalize a calendar entry to one shape regardless of mode.
+ */
+function normalizeCalendar(calendar, local) {
+  if (!local) return { displayName: calendar.displayName, ref: calendar.url, writable: true };
+  return { displayName: calendar.name, ref: calendar.id, writable: calendar.writable };
+}
+
+/**
+ * Handler: List events
+ */
+async function handleListEvents(args) {
+  const count = Math.min(args.count || 25, config.DEFAULTS.MAX_RESULTS);
+  const daysAhead = args.daysAhead || 30;
+
+  const local = isLocalMode();
+  const client = local ? localClient : cloudClient;
+
+  const raw = await client.listEvents(count, daysAhead);
+  const events = raw.map(e => normalizeEvent(e, local));
+
+  if (events.length === 0) {
+    return formatSuccess(`No upcoming events in the next ${daysAhead} days.`, listResult([]));
+  }
+
+  const lines = events.map((event, i) => {
+    const dateStr = event.isAllDay
+      ? `All day: ${formatDate(event.start, { hour: undefined, minute: undefined })}`
+      : `${formatDate(event.start)} - ${formatDate(event.end, { year: undefined, month: undefined, day: undefined })}`;
+
+    let line = `${i + 1}. ${event.summary}\n   ${dateStr}`;
+    if (event.location) line += `\n   Location: ${event.location}`;
+    if (event.calendarName) line += `\n   Calendar: ${event.calendarName}`;
+    line += `\n   ${local ? 'ID' : 'URL'}: ${event.ref}`;
+
+    return line;
+  });
+
+  return formatSuccess(`Upcoming events (${events.length}):\n\n${lines.join('\n\n')}`, listResult(events));
+}
+
+/**
+ * Handler: Create event
+ */
+async function handleCreateEvent(args) {
+  if (!args.summary) {
+    return formatError(new Error('Event summary/title is required'));
+  }
+  if (!args.start) {
+    return formatError(new Error('Start date/time is required (ISO 8601 format)'));
+  }
+  if (!args.end) {
+    return formatError(new Error('End date/time is required (ISO 8601 format)'));
+  }
+
+  const local = isLocalMode();
+  const client = local ? localClient : cloudClient;
+
+  const result = await client.createEvent({
+    summary: args.summary,
+    start: args.start,
+    end: args.end,
+    description: args.description,
+    location: args.location,
+    calendarUrl: args.calendarUrl,   // cloud
+    calendarName: args.calendarName  // local
+  });
+
+  return formatSuccess(
+    `Event created successfully!\n\nTitle: ${args.summary}\nStart: ${formatDate(new Date(args.start))}\nEnd: ${formatDate(new Date(args.end))}${args.location ? `\nLocation: ${args.location}` : ''}${result.calendar ? `\nCalendar: ${result.calendar}` : ''}\n${local ? 'ID' : 'UID'}: ${result.uid || result.id}`
+  );
+}
+
+/**
+ * Handler: Update event
+ */
+async function handleUpdateEvent(args) {
+  if (!args.eventUrl) {
+    return formatError(new Error('Event URL is required (from list-events output)'));
+  }
+
+  const changes = {};
+  for (const field of ['summary', 'start', 'end', 'description', 'location']) {
+    if (args[field] !== undefined) changes[field] = args[field];
+  }
+
+  if (Object.keys(changes).length === 0) {
+    return formatError(new Error('Nothing to update. Provide at least one of: summary, start, end, description, location.'));
+  }
+
+  for (const field of ['start', 'end']) {
+    if (changes[field] !== undefined && Number.isNaN(new Date(changes[field]).getTime())) {
+      return formatError(new Error(`Invalid ${field} date. Use ISO 8601, e.g. 2026-01-15T10:00:00`));
+    }
+  }
+
+  const local = isLocalMode();
+  const client = local ? localClient : cloudClient;
+
+  await client.updateEvent(args.eventUrl, changes);
+
+  const summary = Object.entries(changes)
+    .map(([k, v]) => `${k}: ${v}`)
+    .join('\n');
+
+  return formatSuccess(`Event updated successfully.\n\n${summary}`);
+}
+
+/**
+ * Handler: Delete event
+ */
+async function handleDeleteEvent(args) {
+  if (!args.eventUrl) {
+    return formatError(new Error('Event URL is required'));
+  }
+
+  const client = isLocalMode() ? localClient : cloudClient;
+  await client.deleteEvent(args.eventUrl);
+
+  return formatSuccess(`Event deleted successfully.`);
+}
+
+/**
+ * Handler: List calendars
+ */
+async function handleListCalendars() {
+  const local = isLocalMode();
+  const raw = local ? await localClient.listCalendars() : await cloudClient.getCalendars();
+  const calendars = raw.map(c => normalizeCalendar(c, local));
+
+  if (calendars.length === 0) {
+    return formatSuccess('No calendars found.', listResult([]));
+  }
+
+  const lines = calendars.map((cal, i) =>
+    `${i + 1}. ${cal.displayName}\n   ${local ? 'ID' : 'URL'}: ${cal.ref}`
+  );
+
+  return formatSuccess(`Calendars (${calendars.length}):\n\n${lines.join('\n\n')}`, listResult(calendars));
+}
+
+// Tool definitions
+const calendarTools = [
+  {
+    name: 'list-events',
+    outputSchema: listOutput('Calendar events'),
+    title: 'List Events',
+    description: 'Lists upcoming calendar events',
+    inputSchema: {
+      count: z.number().int().min(1).max(50).optional().describe('Number of events to retrieve (default: 25, max: 50)'),
+      daysAhead: z.number().int().min(1).max(365).optional().describe('Number of days to look ahead (default: 30)')
+    },
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":true},
+    handler: withErrorHandler(handleListEvents, 'list-events')
+  },
+  {
+    name: 'create-event',
+    title: 'Create Event',
+    description: 'Creates a new calendar event',
+    inputSchema: {
+      summary: z.string().describe('Event title/summary'),
+      start: z.string().describe('Start date/time in ISO 8601 format (e.g., 2026-01-15T10:00:00)'),
+      end: z.string().describe('End date/time in ISO 8601 format'),
+      description: z.string().optional().describe('Event description (optional)'),
+      location: z.string().optional().describe('Event location (optional)'),
+      calendarUrl: z.string().optional().describe('Cloud mode: URL of the calendar to add the event to (optional, uses the first calendar)'),
+      calendarName: z.string().optional().describe('Local mode: name of the calendar to add the event to (optional, uses the default)')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":true},
+    handler: withErrorHandler(handleCreateEvent, 'create-event')
+  },
+  {
+    name: 'update-event',
+    title: 'Update Event',
+    description: 'Updates an existing calendar event. Only the fields you pass are changed. In cloud mode the CalDAV property-merge preserves recurrence, invitees and alarms (experimental: the live round-trip is not yet verified).',
+    inputSchema: {
+      eventUrl: z.string().describe('Event handle from list-events: the URL in cloud mode, the UID in local mode'),
+      summary: z.string().optional().describe('New event title (optional)'),
+      start: z.string().optional().describe('New start date/time in ISO 8601 format (optional)'),
+      end: z.string().optional().describe('New end date/time in ISO 8601 format (optional)'),
+      description: z.string().optional().describe('New description (optional)'),
+      location: z.string().optional().describe('New location (optional)')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true},
+    handler: withErrorHandler(handleUpdateEvent, 'update-event')
+  },
+  {
+    name: 'delete-event',
+    title: 'Delete Event',
+    description: 'Deletes a calendar event',
+    inputSchema: {
+      eventUrl: z.string().describe('Event handle from list-events: the URL in cloud mode, the UID in local mode')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":true,"idempotentHint":true,"openWorldHint":true},
+    handler: withErrorHandler(handleDeleteEvent, 'delete-event')
+  },
+  {
+    name: 'list-calendars',
+    outputSchema: listOutput('Calendars'),
+    title: 'List Calendars',
+    description: 'Lists all available calendars',
+    inputSchema: {},
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":true},
+    handler: withErrorHandler(handleListCalendars, 'list-calendars')
+  }
+];
+
+module.exports = {
+  calendarTools,
+  handleListEvents,
+  handleCreateEvent,
+  handleUpdateEvent,
+  handleDeleteEvent,
+  handleListCalendars
+};