mcp-icloud 2.1.5 → 2.2.0

package/README.md

@@ -216,7 +216,11 @@ Mail.app tools iterate messages through AppleScript, which is slow on very large
 
 ### Known limitation: large calendar sets
 
-`list-events` in local mode suffers the same AppleScript wall. The date window is already filtered inside Calendar.app with a `whose` query, but on accounts with many calendars, especially subscribed ones carrying years of events (holidays, sports fixtures, travel feeds), the query can still exceed any reasonable timeout. `list-calendars` and the event write tools are not affected. Until the planned EventKit backend lands (see [#10](https://github.com/MrGo2/icloud-mcp/issues/11)), use cloud mode for reading events: CalDAV filters server-side and is fast at any scale.
+`list-events` in local mode no longer scripts Calendar.app when it can avoid it. It reads the date window straight from EventKit, the macOS calendar store, in one query that returns in about a tenth of a second even with dozens of subscribed calendars. EventKit needs its own permission, separate from Automation: the first `list-events` call asks the program that launches the server (Claude Desktop, your terminal, or your editor) for access to your calendars. Approve it once, or grant it later under **System Settings → Privacy & Security → Calendars**.
+
+If that access is denied, restricted or left unanswered, `list-events` falls back to the old Calendar.app query and logs `EventKit unavailable` on stderr. That path still filters the window inside Calendar.app with a `whose` query, but on accounts with many calendars, especially subscribed ones carrying years of events (holidays, sports fixtures, travel feeds), it can exceed any reasonable timeout. In that case grant Calendars access, or use cloud mode, where CalDAV filters server-side (see [#11](https://github.com/MrGo2/icloud-mcp/issues/11)).
+
+Through EventKit, a recurring event appears once per occurrence in the window, and every occurrence carries the series id. Passing that id to `update-event` or `delete-event` in local mode changes or deletes the whole series.
 
 ### App-specific password (cloud mode)
 

package/calendar/index.js

@@ -209,7 +209,7 @@ const calendarTools = [
   {
     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).',
+    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). In local mode, every occurrence of a recurring event shares the series UID, so this acts on the whole series, not one occurrence.',
     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)'),
@@ -224,7 +224,7 @@ const calendarTools = [
   {
     name: 'delete-event',
     title: 'Delete Event',
-    description: 'Deletes a calendar event',
+    description: 'Deletes a calendar event. In local mode, every occurrence of a recurring event shares the series UID, so this acts on the whole series, not one occurrence.',
     inputSchema: {
       eventUrl: z.string().describe('Event handle from list-events: the URL in cloud mode, the UID in local mode')
     },

package/calendar/local-client.js

@@ -6,8 +6,19 @@
 const { runAppleScript, runJXA, escapeAppleScript, escapeJXA, asInt, appleScriptDateStmts } = require('../utils/applescript');
 const config = require('../config');
 
+// EKAuthorizationStatus: 0 notDetermined, 1 restricted, 2 denied, 3 fullAccess, 4 writeOnly
+const EK_FULL_ACCESS = 3;
+// How long to wait for the user to answer the Calendars permission prompt.
+// The completion block never fires inside osascript, so the status is polled.
+const EK_REQUEST_TIMEOUT_SECONDS = 25;
+// Ask for access at most once per server process: a host that never shows the
+// prompt would otherwise pay the full timeout on every call.
+let eventKitRequested = false;
+
 /**
- * List upcoming events from every calendar
+ * List upcoming events from every calendar.
+ * Uses EventKit (fast, one store query) when the host has full Calendars
+ * access; otherwise falls back to scripting Calendar.app.
  * @param {number} count - Number of events to retrieve
  * @param {number} daysAhead - Number of days to look ahead
  * @returns {Promise<Array>} - List of events
@@ -16,6 +27,93 @@ async function listEvents(count = 25, daysAhead = 30) {
   const now = new Date();
   const future = new Date(now.getTime() + asInt(daysAhead, 30) * 24 * 60 * 60 * 1000);
 
+  let status;
+  try {
+    const result = JSON.parse(await runJXA(eventKitScript(now, future, !eventKitRequested)));
+    status = result.status;
+    if (result.requested) eventKitRequested = true;
+    if (status === EK_FULL_ACCESS && Array.isArray(result.events)) {
+      return sortAndSlice(result.events, count);
+    }
+  } catch (error) {
+    status = 'error: ' + error.message;
+  }
+
+  console.error(`[icloud-mcp] list-events: EventKit unavailable (status ${status}), using Calendar.app`);
+  return listEventsAppleScript(count, now, future);
+}
+
+/**
+ * JXA that reads the window from EventKit. Occurrences of recurring events
+ * are expanded; each carries its series' calendarItemIdentifier, which is
+ * the Calendar.app `uid` that update-event and delete-event resolve.
+ */
+function eventKitScript(now, future, request) {
+  return `
+    ObjC.import('EventKit');
+    ObjC.import('Foundation');
+    const T = $.EKEntityTypeEvent;
+    const store = $.EKEventStore.alloc.init;
+    const readStatus = () => Number($.EKEventStore.authorizationStatusForEntityType(T));
+    let status = readStatus();
+    let requested = false;
+
+    if (${request ? 'true' : 'false'} && (status === 0 || status === 4)) {
+      requested = true;
+      if (store.respondsToSelector('requestFullAccessToEventsWithCompletion:')) {
+        store.requestFullAccessToEventsWithCompletion((granted, err) => {});
+      } else {
+        store.requestAccessToEntityTypeCompletion(T, (granted, err) => {});
+      }
+      const deadline = Date.now() + ${asInt(EK_REQUEST_TIMEOUT_SECONDS, 25)} * 1000;
+      while (status !== 3 && Date.now() < deadline) {
+        $.NSRunLoop.currentRunLoop.runUntilDate($.NSDate.dateWithTimeIntervalSinceNow(0.2));
+        status = readStatus();
+        if (status === 1 || status === 2) break;
+      }
+    }
+
+    let events = null;
+    if (status === 3) {
+      const rangeStart = new Date(${JSON.stringify(now.toISOString())});
+      const rangeEnd = new Date(${JSON.stringify(future.toISOString())});
+      const nsDate = (d) => $.NSDate.dateWithTimeIntervalSince1970(d.getTime() / 1000);
+      const toDate = (ns) => ns && !ns.isNil() ? new Date(Number(ns.timeIntervalSince1970) * 1000) : null;
+      const pred = store.predicateForEventsWithStartDateEndDateCalendars(nsDate(rangeStart), nsDate(rangeEnd), $());
+      const evs = store.eventsMatchingPredicate(pred);
+      events = [];
+      for (let i = 0; i < evs.count; i++) {
+        const ev = evs.objectAtIndex(i);
+        const start = toDate(ev.startDate);
+        // Same window as the Calendar.app path: events starting inside it.
+        if (!start || start < rangeStart || start > rangeEnd) continue;
+        const end = toDate(ev.endDate);
+        events.push({
+          id: ObjC.unwrap(ev.calendarItemIdentifier),
+          summary: ObjC.unwrap(ev.title) || '',
+          startDate: start.toISOString(),
+          endDate: end ? end.toISOString() : null,
+          location: ObjC.unwrap(ev.location) || '',
+          calendar: ObjC.unwrap(ev.calendar.title)
+        });
+      }
+    }
+
+    JSON.stringify({ status, requested, events });
+  `;
+}
+
+function sortAndSlice(events, count) {
+  events.sort((a, b) => new Date(a.startDate) - new Date(b.startDate));
+  return events.slice(0, asInt(count, 25));
+}
+
+/**
+ * Calendar.app path: used when EventKit access is not granted.
+ * Slow on accounts with many or subscribed calendars.
+ */
+async function listEventsAppleScript(count, now, future) {
+
   // 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.
@@ -70,9 +168,7 @@ async function listEvents(count = 25, daysAhead = 30) {
   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));
+  return sortAndSlice(JSON.parse(result), count);
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-icloud",
   "mcpName": "io.github.MrGo2/icloud-mcp",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "MCP server for Apple services - Email, Calendar, Contacts, Reminders, Notes, Messages and Safari - with dual local (AppleScript) and cloud (IMAP/CalDAV/CardDAV) modes",
   "main": "index.js",
   "bin": {
@@ -27,7 +27,7 @@
   ],
   "scripts": {
     "start": "node index.js",
-    "test": "node test/security.test.js && node test/local-output.test.js && node test/email-read.test.js && node test/messages.test.js",
+    "test": "node test/security.test.js && node test/local-output.test.js && node test/email-read.test.js && node test/messages.test.js && node test/calendar-eventkit.test.js",
     "test-mode": "USE_TEST_MODE=true node index.js",
     "inspect": "npx @modelcontextprotocol/inspector node index.js",
     "test:local": "node test/local-output.test.js"