mcp-icloud 2.1.1

package/calendar/local-client.js

@@ -0,0 +1,223 @@
+/**
+ * Local Calendar Client
+ * Accesses Calendar.app via AppleScript
+ */
+
+const { runAppleScript, runJXA, escapeAppleScript, escapeJXA, asInt, formatAppleScriptDate } = require('../utils/applescript');
+const config = require('../config');
+
+/**
+ * List upcoming events from every calendar
+ * @param {number} count - Number of events to retrieve
+ * @param {number} daysAhead - Number of days to look ahead
+ * @returns {Promise<Array>} - List of events
+ */
+async function listEvents(count = 25, daysAhead = 30) {
+  const now = new Date();
+  const future = new Date(now.getTime() + asInt(daysAhead, 30) * 24 * 60 * 60 * 1000);
+
+  // Batch property access: per-event JXA calls trigger AppleEvent errors.
+  // The window is filtered inside the script so a busy calendar cannot push
+  // upcoming events out of the result set before we ever see them.
+  const script = `
+    const calendar = Application('Calendar');
+    const cals = calendar.calendars;
+    const calNames = cals.name();
+    const rangeStart = new Date(${JSON.stringify(now.toISOString())});
+    const rangeEnd = new Date(${JSON.stringify(future.toISOString())});
+    let allEvents = [];
+
+    for (let i = 0; i < calNames.length; i++) {
+      try {
+        // Filter the window app-side: reading every property of every event
+        // of every calendar transfers whole subscribed-calendar histories
+        // and hangs on real accounts.
+        const evts = cals[i].events.whose({
+          _and: [
+            { startDate: { _greaterThan: rangeStart } },
+            { startDate: { _lessThan: rangeEnd } }
+          ]
+        });
+        const uids = evts.uid();
+        const summaries = evts.summary();
+        const starts = evts.startDate();
+        const ends = evts.endDate();
+        const locations = evts.location();
+
+        for (let j = 0; j < uids.length; j++) {
+          const start = starts[j];
+          if (!start) continue;
+          if (start < rangeStart || start > rangeEnd) continue;
+
+          allEvents.push({
+            id: uids[j],
+            summary: summaries[j] || '',
+            startDate: start.toISOString(),
+            endDate: ends[j] ? ends[j].toISOString() : null,
+            location: locations[j] || '',
+            calendar: calNames[i]
+          });
+        }
+      } catch (e) {
+        // One unreadable calendar must not hide the rest, but say which.
+        console.log('calendar skipped: ' + calNames[i] + ' (' + e + ')');
+      }
+    }
+
+    JSON.stringify(allEvents);
+  `;
+
+  const result = await runJXA(script);
+  if (!result) return [];
+
+  const events = JSON.parse(result);
+  events.sort((a, b) => new Date(a.startDate) - new Date(b.startDate));
+  return events.slice(0, asInt(count, 25));
+}
+
+/**
+ * List all calendars
+ * @returns {Promise<Array>} - List of calendars
+ */
+async function listCalendars() {
+  // Use batch property access - JXA iteration causes AppleEvent errors
+  const script = `
+    const calendar = Application('Calendar');
+    const cals = calendar.calendars;
+    const names = cals.name();
+    const writables = cals.writable();
+
+    let result = [];
+    for (let i = 0; i < names.length; i++) {
+      result.push({
+        name: names[i],
+        id: names[i], // Use name as ID since cal.id() causes errors
+        writable: writables[i]
+      });
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * Create a new event
+ * @param {Object} options - Event options
+ * @returns {Promise<Object>} - Created event info
+ */
+async function createEvent({ summary, start, end, location, description, calendarName, allDay = false }) {
+  const startDate = new Date(start);
+  const endDate = new Date(end);
+
+  // Use default calendar if none specified
+  const targetCalendar = calendarName || 'Calendar';
+
+  if (allDay) {
+    // All-day event
+    const script = `
+      tell application "Calendar"
+        tell calendar "${escapeAppleScript(targetCalendar)}"
+          set newEvent to make new event with properties {summary:"${escapeAppleScript(summary)}", start date:date "${formatAppleScriptDate(startDate)}", end date:date "${formatAppleScriptDate(endDate)}", allday event:true}
+          ${location ? `set location of newEvent to "${escapeAppleScript(location)}"` : ''}
+          ${description ? `set description of newEvent to "${escapeAppleScript(description)}"` : ''}
+          return uid of newEvent
+        end tell
+      end tell
+    `;
+
+    const uid = await runAppleScript(script);
+    return { success: true, id: uid, message: 'Event created successfully' };
+  } else {
+    const script = `
+      tell application "Calendar"
+        tell calendar "${escapeAppleScript(targetCalendar)}"
+          set newEvent to make new event with properties {summary:"${escapeAppleScript(summary)}", start date:date "${formatAppleScriptDate(startDate)}", end date:date "${formatAppleScriptDate(endDate)}"}
+          ${location ? `set location of newEvent to "${escapeAppleScript(location)}"` : ''}
+          ${description ? `set description of newEvent to "${escapeAppleScript(description)}"` : ''}
+          return uid of newEvent
+        end tell
+      end tell
+    `;
+
+    const uid = await runAppleScript(script);
+    return { success: true, id: uid, message: 'Event created successfully' };
+  }
+}
+
+/**
+ * Update an existing event
+ * @param {string} eventId - Event UID
+ * @param {Object} updates - Fields to update
+ * @returns {Promise<Object>} - Result
+ */
+async function updateEvent(eventId, { summary, start, end, location, description }) {
+  let updateCommands = [];
+
+  if (summary) updateCommands.push(`set summary of theEvent to "${escapeAppleScript(summary)}"`);
+  if (start) updateCommands.push(`set start date of theEvent to date "${formatAppleScriptDate(new Date(start))}"`);
+  if (end) updateCommands.push(`set end date of theEvent to date "${formatAppleScriptDate(new Date(end))}"`);
+  if (location !== undefined) updateCommands.push(`set location of theEvent to "${escapeAppleScript(location || '')}"`);
+  if (description !== undefined) updateCommands.push(`set description of theEvent to "${escapeAppleScript(description || '')}"`);
+
+  if (updateCommands.length === 0) {
+    return { success: false, message: 'No updates provided' };
+  }
+
+  const script = `
+    tell application "Calendar"
+      set allCalendars to calendars
+      repeat with cal in allCalendars
+        try
+          set theEvent to first event of cal whose uid is "${escapeAppleScript(eventId)}"
+          ${updateCommands.join('\n          ')}
+          return "updated"
+        end try
+      end repeat
+      return "not found"
+    end tell
+  `;
+
+  const result = await runAppleScript(script);
+  if (result === 'not found') {
+    return { success: false, message: 'Event not found' };
+  }
+  return { success: true, message: 'Event updated successfully' };
+}
+
+/**
+ * Delete an event
+ * @param {string} eventId - Event UID
+ * @returns {Promise<Object>} - Result
+ */
+async function deleteEvent(eventId) {
+  const script = `
+    tell application "Calendar"
+      set allCalendars to calendars
+      repeat with cal in allCalendars
+        try
+          set theEvent to first event of cal whose uid is "${escapeAppleScript(eventId)}"
+          delete theEvent
+          return "deleted"
+        end try
+      end repeat
+      return "not found"
+    end tell
+  `;
+
+  const result = await runAppleScript(script);
+  if (result === 'not found') {
+    return { success: false, message: 'Event not found' };
+  }
+  return { success: true, message: 'Event deleted successfully' };
+}
+
+module.exports = {
+  listEvents,
+  listCalendars,
+  createEvent,
+  updateEvent,
+  deleteEvent
+};

package/config.js

@@ -0,0 +1,69 @@
+/**
+ * iCloud MCP Configuration
+ * Centralized configuration for all iCloud services
+ */
+
+// Load .env from the module dir, not the cwd — MCP clients like Claude
+// Desktop launch the server from an arbitrary working directory (issue #3)
+require('dotenv').config({ path: require('path').join(__dirname, '.env') });
+
+module.exports = {
+  // Mode flags
+  USE_TEST_MODE: process.env.USE_TEST_MODE === 'true',
+  USE_LOCAL_MODE: process.env.USE_LOCAL_MODE !== 'false', // Default to true (local mode)
+
+  // Check if running on macOS (required for local mode)
+  IS_MACOS: process.platform === 'darwin',
+
+  // iCloud credentials
+  ICLOUD_EMAIL: process.env.ICLOUD_EMAIL,
+  ICLOUD_APP_PASSWORD: process.env.ICLOUD_APP_PASSWORD,
+
+  // IMAP settings for iCloud Mail
+  IMAP: {
+    HOST: 'imap.mail.me.com',
+    PORT: 993,
+    TLS: true,
+    AUTH_TIMEOUT: 10000,
+    CONN_TIMEOUT: 30000
+  },
+
+  // SMTP settings for sending mail
+  SMTP: {
+    HOST: 'smtp.mail.me.com',
+    PORT: 587,
+    SECURE: false  // Uses STARTTLS
+  },
+
+  // CalDAV settings for Calendar
+  CALDAV: {
+    SERVER_URL: 'https://caldav.icloud.com',
+    // Principal URL will be discovered during auth
+    AUTH_METHOD: 'Basic'
+  },
+
+  // CardDAV settings for Contacts
+  CARDDAV: {
+    SERVER_URL: 'https://contacts.icloud.com',
+    AUTH_METHOD: 'Basic'
+  },
+
+  // Default settings
+  DEFAULTS: {
+    TIMEZONE: 'Europe/Madrid',
+    PAGE_SIZE: 25,
+    MAX_RESULTS: 50,
+    EMAIL_BODY_MAX_LENGTH: 50000,
+    DATE_FORMAT: 'es-ES'
+  },
+
+  // Email folder mappings
+  EMAIL_FOLDERS: {
+    inbox: 'INBOX',
+    sent: 'Sent Messages',
+    drafts: 'Drafts',
+    trash: 'Deleted Messages',
+    archive: 'Archive',
+    junk: 'Junk'
+  }
+};

package/contacts/carddav-client.js

@@ -0,0 +1,331 @@
+/**
+ * CardDAV client for iCloud Contacts
+ */
+
+const { DAVClient } = require('tsdav');
+const config = require('../config');
+const { getCredentials } = require('../auth');
+
+let cachedClient = null;
+
+/**
+ * Get or create CardDAV client
+ */
+async function getClient() {
+  if (cachedClient) {
+    return cachedClient;
+  }
+
+  const creds = getCredentials();
+
+  const client = new DAVClient({
+    serverUrl: config.CARDDAV.SERVER_URL,
+    credentials: {
+      username: creds.email,
+      password: creds.password
+    },
+    authMethod: 'Basic',
+    defaultAccountType: 'carddav'
+  });
+
+  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
+ */
+function clearClient() {
+  cachedClient = null;
+}
+
+/**
+ * Parse vCard to simple object
+ */
+function parseVCard(vcardData, url) {
+  try {
+    const contact = {
+      url,
+      uid: '',
+      displayName: '',
+      firstName: '',
+      lastName: '',
+      emails: [],
+      phones: [],
+      organization: '',
+      title: '',
+      notes: ''
+    };
+
+    const lines = vcardData.split(/\r?\n/);
+
+    for (const line of lines) {
+      const colonIndex = line.indexOf(':');
+      if (colonIndex === -1) continue;
+
+      const key = line.substring(0, colonIndex).toUpperCase();
+      const value = line.substring(colonIndex + 1);
+
+      // Handle property parameters (like TYPE=WORK)
+      const keyParts = key.split(';');
+      const mainKey = keyParts[0];
+
+      switch (mainKey) {
+        case 'UID':
+          contact.uid = value;
+          break;
+        case 'FN':
+          contact.displayName = decodeVCardValue(value);
+          break;
+        case 'N':
+          const nameParts = value.split(';');
+          contact.lastName = decodeVCardValue(nameParts[0] || '');
+          contact.firstName = decodeVCardValue(nameParts[1] || '');
+          break;
+        case 'EMAIL':
+          const emailType = extractType(keyParts) || 'other';
+          contact.emails.push({ type: emailType, value: decodeVCardValue(value) });
+          break;
+        case 'TEL':
+          const phoneType = extractType(keyParts) || 'other';
+          contact.phones.push({ type: phoneType, value: decodeVCardValue(value) });
+          break;
+        case 'ORG':
+          contact.organization = decodeVCardValue(value.split(';')[0]);
+          break;
+        case 'TITLE':
+          contact.title = decodeVCardValue(value);
+          break;
+        case 'NOTE':
+          contact.notes = decodeVCardValue(value);
+          break;
+      }
+    }
+
+    // Use first/last name if no display name
+    if (!contact.displayName && (contact.firstName || contact.lastName)) {
+      contact.displayName = `${contact.firstName} ${contact.lastName}`.trim();
+    }
+
+    return contact;
+  } catch (error) {
+    console.error('Error parsing vCard:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Extract TYPE parameter from vCard property
+ */
+function extractType(keyParts) {
+  for (const part of keyParts) {
+    if (part.startsWith('TYPE=')) {
+      return part.substring(5).toLowerCase();
+    }
+  }
+  return null;
+}
+
+/**
+ * Decode vCard escaped value
+ */
+function decodeVCardValue(value) {
+  if (!value) return '';
+  return value
+    .replace(/\\n/gi, '\n')
+    .replace(/\\,/g, ',')
+    .replace(/\\;/g, ';')
+    .replace(/\\\\/g, '\\');
+}
+
+/**
+ * Encode value for vCard
+ */
+function encodeVCardValue(value) {
+  if (!value) return '';
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/;/g, '\\;')
+    .replace(/,/g, '\\,')
+    .replace(/\n/g, '\\n');
+}
+
+/**
+ * Get all address books
+ */
+async function getAddressBooks() {
+  const client = await getClient();
+  const addressBooks = await client.fetchAddressBooks();
+  return addressBooks.map(ab => ({
+    url: ab.url,
+    displayName: ab.displayName || 'Contacts'
+  }));
+}
+
+/**
+ * Fetch every contact from every address book, sorted by display name
+ */
+async function fetchAllContacts() {
+  const client = await getClient();
+  const addressBooks = await client.fetchAddressBooks();
+
+  const allContacts = [];
+
+  for (const addressBook of addressBooks) {
+    try {
+      const vcards = await client.fetchVCards({ addressBook });
+
+      for (const vcard of vcards) {
+        const contact = parseVCard(vcard.data, vcard.url);
+        if (contact && contact.displayName) {
+          allContacts.push(contact);
+        }
+      }
+    } catch (error) {
+      console.error(`Error fetching from address book:`, error.message);
+    }
+  }
+
+  // Sort by display name
+  allContacts.sort((a, b) => a.displayName.localeCompare(b.displayName));
+
+  return allContacts;
+}
+
+/**
+ * List contacts
+ */
+async function listContacts(count = 25) {
+  const allContacts = await fetchAllContacts();
+  return allContacts.slice(0, count);
+}
+
+/**
+ * Search contacts
+ */
+async function searchContacts(query, count = 25) {
+  // Search the FULL contact list; capping before filtering missed anyone
+  // past the first `count * 2` in alphabetical order (issue behind PR #4/#7)
+  const allContacts = await fetchAllContacts();
+  const lowerQuery = query.toLowerCase();
+
+  const matches = allContacts.filter(contact => {
+    const searchText = [
+      contact.displayName,
+      contact.firstName,
+      contact.lastName,
+      contact.organization,
+      ...contact.emails.map(e => e.value),
+      ...contact.phones.map(p => p.value)
+    ].join(' ').toLowerCase();
+
+    return searchText.includes(lowerQuery);
+  });
+
+  return matches.slice(0, count);
+}
+
+/**
+ * Get contact by URL
+ */
+async function getContact(contactUrl) {
+  const client = await getClient();
+
+  const vcard = await client.fetchVCards({
+    addressBook: { url: contactUrl.substring(0, contactUrl.lastIndexOf('/') + 1) },
+    objectUrls: [contactUrl]
+  });
+
+  if (vcard && vcard[0]) {
+    return parseVCard(vcard[0].data, vcard[0].url);
+  }
+
+  throw new Error('Contact not found');
+}
+
+/**
+ * Create a new contact
+ */
+async function createContact({ displayName, firstName, lastName, email, phone, organization, title, notes }) {
+  const client = await getClient();
+  const addressBooks = await client.fetchAddressBooks();
+
+  if (addressBooks.length === 0) {
+    throw new Error('No address book found');
+  }
+
+  const addressBook = addressBooks[0];
+  const uid = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+  let vcard = `BEGIN:VCARD
+VERSION:3.0
+UID:${uid}
+FN:${encodeVCardValue(displayName || `${firstName || ''} ${lastName || ''}`.trim())}
+N:${encodeVCardValue(lastName || '')};${encodeVCardValue(firstName || '')};;;`;
+
+  if (email) {
+    vcard += `\nEMAIL;TYPE=INTERNET:${encodeVCardValue(email)}`;
+  }
+  if (phone) {
+    vcard += `\nTEL;TYPE=CELL:${encodeVCardValue(phone)}`;
+  }
+  if (organization) {
+    vcard += `\nORG:${encodeVCardValue(organization)}`;
+  }
+  if (title) {
+    vcard += `\nTITLE:${encodeVCardValue(title)}`;
+  }
+  if (notes) {
+    vcard += `\nNOTE:${encodeVCardValue(notes)}`;
+  }
+
+  vcard += `\nEND:VCARD`;
+
+  const result = await client.createVCard({
+    addressBook,
+    filename: `${uid}.vcf`,
+    vCardString: vcard
+  });
+
+  return {
+    success: true,
+    uid,
+    url: result?.url
+  };
+}
+
+/**
+ * Delete a contact
+ */
+async function deleteContact(contactUrl) {
+  const client = await getClient();
+
+  await client.deleteVCard({
+    vCard: {
+      url: contactUrl,
+      etag: ''
+    }
+  });
+
+  return { success: true };
+}
+
+module.exports = {
+  getClient,
+  clearClient,
+  getAddressBooks,
+  listContacts,
+  searchContacts,
+  getContact,
+  createContact,
+  deleteContact,
+  parseVCard
+};