mcp-icloud 2.1.1

package/notes/local-client.js

@@ -0,0 +1,203 @@
+/**
+ * Local Notes Client
+ * Accesses Notes.app via AppleScript
+ */
+
+const { runAppleScript, runJXA, escapeAppleScript, escapeJXA, asInt } = require('../utils/applescript');
+
+/**
+ * List note folders
+ * @returns {Promise<Array>} - List of folders
+ */
+async function listNoteFolders() {
+  const script = `
+    const notes = Application('Notes');
+    const folders = notes.folders();
+    let result = [];
+
+    for (let folder of folders) {
+      try {
+        result.push({
+          id: folder.id(),
+          name: folder.name(),
+          noteCount: folder.notes().length
+        });
+      } catch (e) {}
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * List notes
+ * @param {string} folderName - Folder name (optional)
+ * @param {number} count - Max notes to return
+ * @returns {Promise<Array>} - List of notes
+ */
+async function listNotes(folderName = null, count = 25) {
+  const script = `
+    const notes = Application('Notes');
+    let allNotes = [];
+
+    ${folderName ? `
+    const folder = notes.folders.byName("${escapeJXA(folderName)}");
+    const notesList = folder.notes();
+    for (let note of notesList) {
+      allNotes.push({
+        id: note.id(),
+        name: note.name(),
+        creationDate: note.creationDate().toISOString(),
+        modificationDate: note.modificationDate().toISOString(),
+        folder: "${escapeJXA(folderName)}"
+      });
+    }
+    ` : `
+    const folders = notes.folders();
+    for (let folder of folders) {
+      try {
+        const notesList = folder.notes();
+        for (let note of notesList) {
+          allNotes.push({
+            id: note.id(),
+            name: note.name(),
+            creationDate: note.creationDate().toISOString(),
+            modificationDate: note.modificationDate().toISOString(),
+            folder: folder.name()
+          });
+        }
+      } catch (e) {}
+    }
+    `}
+
+    // Sort by modification date (newest first)
+    allNotes.sort((a, b) => new Date(b.modificationDate) - new Date(a.modificationDate));
+    JSON.stringify(allNotes.slice(0, ${asInt(count, 25)}));
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * Read a note's content
+ * @param {string} noteId - Note ID
+ * @returns {Promise<Object>} - Note content
+ */
+async function readNote(noteId) {
+  const script = `
+    const notes = Application('Notes');
+    const folders = notes.folders();
+
+    for (let folder of folders) {
+      try {
+        const notesList = folder.notes();
+        for (let note of notesList) {
+          if (note.id() === "${escapeJXA(noteId)}") {
+            // Get plain text by stripping HTML
+            const body = note.body();
+            const plaintext = note.plaintext();
+
+            return JSON.stringify({
+              id: note.id(),
+              name: note.name(),
+              body: body,
+              plaintext: plaintext,
+              creationDate: note.creationDate().toISOString(),
+              modificationDate: note.modificationDate().toISOString(),
+              folder: folder.name()
+            });
+          }
+        }
+      } catch (e) {}
+    }
+
+    return JSON.stringify(null);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : null;
+}
+
+/**
+ * Create a new note
+ * @param {Object} options - Note options
+ * @returns {Promise<Object>} - Created note info
+ */
+async function createNote({ title, body, folderName = 'Notes' }) {
+  // Notes uses an HTML body. Split on real newlines BEFORE escaping: escaping
+  // turns a newline into the two characters \ and n, so a replace afterwards
+  // would find nothing and the note would render with literal \n in it.
+  const htmlLines = String(body || '').split('\n').map(escapeAppleScript).join('<br>');
+  const htmlBody = `<h1>${escapeAppleScript(title)}</h1><br>${htmlLines}`;
+
+  const script = `
+    tell application "Notes"
+      tell folder "${escapeAppleScript(folderName)}"
+        set newNote to make new note with properties {body:"${htmlBody}"}
+        return id of newNote
+      end tell
+    end tell
+  `;
+
+  const id = await runAppleScript(script);
+  return { success: true, id, message: 'Note created successfully' };
+}
+
+/**
+ * Search notes
+ * @param {string} query - Search query
+ * @param {number} count - Max results
+ * @returns {Promise<Array>} - Matching notes
+ */
+async function searchNotes(query, count = 25) {
+  const searchTerm = escapeJXA(query.toLowerCase());
+  const limit = asInt(count, 25);
+
+  const script = `
+    const notes = Application('Notes');
+    const folders = notes.folders();
+    let results = [];
+
+    for (let folder of folders) {
+      if (results.length >= ${limit}) break;
+
+      try {
+        const notesList = folder.notes();
+        for (let note of notesList) {
+          if (results.length >= ${limit}) break;
+
+          const name = (note.name() || '').toLowerCase();
+          const plaintext = (note.plaintext() || '').toLowerCase();
+
+          if (name.includes("${searchTerm}") || plaintext.includes("${searchTerm}")) {
+            results.push({
+              id: note.id(),
+              name: note.name(),
+              creationDate: note.creationDate().toISOString(),
+              modificationDate: note.modificationDate().toISOString(),
+              folder: folder.name(),
+              snippet: note.plaintext().substring(0, 200)
+            });
+          }
+        }
+      } catch (e) {}
+    }
+
+    JSON.stringify(results);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+module.exports = {
+  listNoteFolders,
+  listNotes,
+  readNote,
+  createNote,
+  searchNotes
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "mcp-icloud",
+  "mcpName": "io.github.MrGo2/icloud-mcp",
+  "version": "2.1.1",
+  "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": {
+    "icloud-mcp": "index.js"
+  },
+  "files": [
+    "index.js",
+    "mode.js",
+    "config.js",
+    "auth/",
+    "email/",
+    "calendar/",
+    "contacts/",
+    "reminders/",
+    "notes/",
+    "messages/",
+    "safari/",
+    "utils/",
+    "LICENSE",
+    "README.md",
+    "DISCLOSURE"
+  ],
+  "scripts": {
+    "start": "node index.js",
+    "test": "node test/security.test.js && node test/local-output.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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MrGo2/icloud-mcp.git"
+  },
+  "homepage": "https://github.com/MrGo2/icloud-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/MrGo2/icloud-mcp/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "icloud",
+    "apple",
+    "applescript",
+    "imap",
+    "caldav",
+    "carddav",
+    "claude",
+    "reminders",
+    "notes",
+    "imessage",
+    "safari"
+  ],
+  "author": "Carlos Lorenzo",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/server": "2.0.0",
+    "dotenv": "^16.4.5",
+    "ical.js": "^2.1.0",
+    "imap": "^0.8.19",
+    "mailparser": "^3.7.1",
+    "nodemailer": "^9.0.1",
+    "tsdav": "^2.1.1",
+    "zod": "^4.4.3"
+  },
+  "contentPolicy": {
+    "class": "dual-use"
+  }
+}

package/reminders/index.js

@@ -0,0 +1,215 @@
+/**
+ * Reminders Module
+ * MCP tool definitions for Reminders.app
+ * NOTE: Only available in LOCAL mode (AppleScript)
+ */
+
+const { z } = require('zod');
+const localClient = require('./local-client');
+const { formatError } = require('../utils/error-handler');
+const { listOutput, listResult } = require('../utils/schemas');
+const { isLocalMode } = require('../mode');
+
+/**
+ * Check if we're in local mode, return error if not
+ */
+function requireLocalMode(toolName) {
+  if (!isLocalMode()) {
+    return formatError(new Error(`${toolName} is only available in LOCAL mode. Use set-mode to switch.`));
+  }
+  return null;
+}
+
+const remindersTools = [
+  {
+    name: 'list-reminder-lists',
+    outputSchema: listOutput('list-reminder-lists'),
+    title: 'List Reminder Lists',
+    description: 'Lists all reminder lists from Reminders.app (LOCAL mode only)',
+    inputSchema: {},
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async () => {
+      const modeError = requireLocalMode('list-reminder-lists');
+      if (modeError) return modeError;
+
+      try {
+        const lists = await localClient.listReminderLists();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(lists, null, 2)
+          }],
+          structuredContent: listResult(lists)
+        };
+      } catch (error) {
+        return formatError(error, 'list-reminder-lists');
+      }
+    }
+  },
+  {
+    name: 'list-reminders',
+    outputSchema: listOutput('list-reminders'),
+    title: 'List Reminders',
+    description: 'Lists reminders from a specific list or all lists (LOCAL mode only)',
+    inputSchema: {
+      listName: z.string().optional().describe('Name of the reminder list (optional, lists all if not provided)'),
+      includeCompleted: z.boolean().optional().describe('Include completed reminders (default: false)'),
+      count: z.number().int().min(1).max(200).optional().describe('Maximum number of reminders to return (default: 50)')
+    },
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async ({ listName, includeCompleted = false, count = 50 }) => {
+      const modeError = requireLocalMode('list-reminders');
+      if (modeError) return modeError;
+
+      try {
+        const reminders = await localClient.listReminders(listName, includeCompleted, count);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(reminders, null, 2)
+          }],
+          structuredContent: listResult(reminders)
+        };
+      } catch (error) {
+        return formatError(error, 'list-reminders');
+      }
+    }
+  },
+  {
+    name: 'create-reminder',
+    title: 'Create Reminder',
+    description: 'Creates a new reminder (LOCAL mode only)',
+    inputSchema: {
+      name: z.string().describe('Reminder title (required)'),
+      body: z.string().optional().describe('Reminder notes/description'),
+      dueDate: z.string().optional().describe('Due date in ISO format (e.g., 2026-01-15T10:00:00)'),
+      listName: z.string().optional().describe('Name of the list to add to (default: Reminders)'),
+      priority: z.number().int().min(0).max(9).optional().describe('Priority level (0=none, 1=high, 5=medium, 9=low)')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":false},
+    handler: async (args) => {
+      const modeError = requireLocalMode('create-reminder');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.createReminder(args);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'create-reminder');
+      }
+    }
+  },
+  {
+    name: 'update-reminder',
+    title: 'Update Reminder',
+    description: 'Updates an existing reminder (LOCAL mode only)',
+    inputSchema: {
+      reminderId: z.string().describe('ID of the reminder to update (required)'),
+      name: z.string().optional().describe('New title'),
+      body: z.string().optional().describe('New notes/description'),
+      dueDate: z.string().optional().describe('New due date in ISO format'),
+      priority: z.number().int().min(0).max(9).optional().describe('New priority level')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false},
+    handler: async ({ reminderId, ...updates }) => {
+      const modeError = requireLocalMode('update-reminder');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.updateReminder(reminderId, updates);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'update-reminder');
+      }
+    }
+  },
+  {
+    name: 'complete-reminder',
+    title: 'Complete Reminder',
+    description: 'Marks a reminder as complete or incomplete (LOCAL mode only)',
+    inputSchema: {
+      reminderId: z.string().describe('ID of the reminder (required)'),
+      completed: z.boolean().optional().describe('Set to true to complete, false to uncomplete (default: true)')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false},
+    handler: async ({ reminderId, completed = true }) => {
+      const modeError = requireLocalMode('complete-reminder');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.completeReminder(reminderId, completed);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'complete-reminder');
+      }
+    }
+  },
+  {
+    name: 'delete-reminder',
+    title: 'Delete Reminder',
+    description: 'Deletes a reminder (LOCAL mode only)',
+    inputSchema: {
+      reminderId: z.string().describe('ID of the reminder to delete (required)')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async ({ reminderId }) => {
+      const modeError = requireLocalMode('delete-reminder');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.deleteReminder(reminderId);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'delete-reminder');
+      }
+    }
+  },
+  {
+    name: 'search-reminders',
+    title: 'Search Reminders',
+    description: 'Search reminders by text in name or body (LOCAL mode only)',
+    inputSchema: {
+      query: z.string().describe('Search text (required)'),
+      count: z.number().int().min(1).max(200).optional().describe('Maximum results to return (default: 25)')
+    },
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async ({ query, count = 25 }) => {
+      const modeError = requireLocalMode('search-reminders');
+      if (modeError) return modeError;
+
+      try {
+        const results = await localClient.searchReminders(query, count);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(results, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'search-reminders');
+      }
+    }
+  }
+];
+
+module.exports = { remindersTools };