mcp-icloud 2.1.1

package/reminders/local-client.js

@@ -0,0 +1,269 @@
+/**
+ * Local Reminders Client
+ * Accesses Reminders.app via AppleScript
+ */
+
+const { runAppleScript, runJXA, escapeAppleScript, escapeJXA, asInt, asBool, formatAppleScriptDate } = require('../utils/applescript');
+
+/**
+ * List all reminder lists
+ * @returns {Promise<Array>} - List of reminder lists
+ */
+async function listReminderLists() {
+  // Names and ids only, fetched as two batch calls. Counting reminders per
+  // list forces one Apple Event round-trip per reminder over the full
+  // history (completed included) and hangs for minutes on a real database.
+  const script = `
+    const reminders = Application('Reminders');
+    const lists = reminders.lists;
+    const names = lists.name();
+    const ids = lists.id();
+    let result = [];
+
+    for (let i = 0; i < names.length; i++) {
+      result.push({ id: ids[i], name: names[i] });
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * List reminders from a list
+ * @param {string} listName - List name (optional, defaults to all)
+ * @param {boolean} includeCompleted - Include completed reminders
+ * @param {number} count - Max reminders to return
+ * @returns {Promise<Array>} - List of reminders
+ */
+async function listReminders(listName = null, includeCompleted = false, count = 50) {
+  const limit = asInt(count, 50);
+
+  const script = `
+    const reminders = Application('Reminders');
+    let allReminders = [];
+    const includeCompleted = ${asBool(includeCompleted)};
+    const targetListName = ${listName ? `"${escapeJXA(listName)}"` : 'null'};
+
+    const lists = reminders.lists();
+    for (let i = 0; i < lists.length; i++) {
+      const list = lists[i];
+      if (targetListName && list.name() !== targetListName) continue;
+
+      try {
+        const rems = list.reminders();
+        for (let j = 0; j < rems.length; j++) {
+          const r = rems[j];
+          const isCompleted = r.completed();
+          if (!includeCompleted && isCompleted) continue;
+
+          let dueDate = null;
+          try { dueDate = r.dueDate() ? r.dueDate().toISOString() : null; } catch(e) {}
+
+          allReminders.push({
+            id: r.id(),
+            name: r.name(),
+            body: r.body() || '',
+            completed: isCompleted,
+            dueDate: dueDate,
+            priority: r.priority(),
+            list: list.name()
+          });
+        }
+      } catch (e) {}
+    }
+
+    // Sort by due date (nulls at end)
+    allReminders.sort(function(a, b) {
+      if (!a.dueDate && !b.dueDate) return 0;
+      if (!a.dueDate) return 1;
+      if (!b.dueDate) return -1;
+      return new Date(a.dueDate) - new Date(b.dueDate);
+    });
+
+    JSON.stringify(allReminders.slice(0, ${limit}));
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * Create a new reminder
+ * @param {Object} options - Reminder options
+ * @returns {Promise<Object>} - Created reminder info
+ */
+async function createReminder({ name, body, dueDate, listName = 'Reminders', priority = 0 }) {
+  let properties = [`name:"${escapeAppleScript(name)}"`];
+
+  if (body) properties.push(`body:"${escapeAppleScript(body)}"`);
+  if (priority) properties.push(`priority:${asInt(priority, 0)}`);
+
+  let script = `
+    tell application "Reminders"
+      tell list "${escapeAppleScript(listName)}"
+        set newReminder to make new reminder with properties {${properties.join(', ')}}
+  `;
+
+  if (dueDate) {
+    script += `
+        set due date of newReminder to date "${formatAppleScriptDate(new Date(dueDate))}"
+    `;
+  }
+
+  script += `
+        return id of newReminder
+      end tell
+    end tell
+  `;
+
+  const id = await runAppleScript(script);
+  return { success: true, id, message: 'Reminder created successfully' };
+}
+
+/**
+ * Update a reminder
+ * @param {string} reminderId - Reminder ID
+ * @param {Object} updates - Fields to update
+ * @returns {Promise<Object>} - Result
+ */
+async function updateReminder(reminderId, { name, body, dueDate, priority }) {
+  let updateCommands = [];
+
+  if (name) updateCommands.push(`set name of theReminder to "${escapeAppleScript(name)}"`);
+  if (body !== undefined) updateCommands.push(`set body of theReminder to "${escapeAppleScript(body || '')}"`);
+  if (priority !== undefined) updateCommands.push(`set priority of theReminder to ${asInt(priority, 0)}`);
+  if (dueDate) updateCommands.push(`set due date of theReminder to date "${formatAppleScriptDate(new Date(dueDate))}"`);
+  if (dueDate === null) updateCommands.push(`set due date of theReminder to missing value`);
+
+  const script = `
+    tell application "Reminders"
+      set allLists to lists
+      repeat with theList in allLists
+        try
+          set theReminder to reminder id "${escapeAppleScript(reminderId)}" of theList
+          ${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: 'Reminder not found' };
+  }
+  return { success: true, message: 'Reminder updated successfully' };
+}
+
+/**
+ * Mark a reminder as complete/incomplete
+ * @param {string} reminderId - Reminder ID
+ * @param {boolean} completed - Completion status
+ * @returns {Promise<Object>} - Result
+ */
+async function completeReminder(reminderId, completed = true) {
+  const script = `
+    tell application "Reminders"
+      set allLists to lists
+      repeat with theList in allLists
+        try
+          set theReminder to reminder id "${escapeAppleScript(reminderId)}" of theList
+          set completed of theReminder to ${asBool(completed, true)}
+          return "done"
+        end try
+      end repeat
+      return "not found"
+    end tell
+  `;
+
+  const result = await runAppleScript(script);
+  if (result === 'not found') {
+    return { success: false, message: 'Reminder not found' };
+  }
+  return { success: true, message: `Reminder marked as ${completed ? 'complete' : 'incomplete'}` };
+}
+
+/**
+ * Delete a reminder
+ * @param {string} reminderId - Reminder ID
+ * @returns {Promise<Object>} - Result
+ */
+async function deleteReminder(reminderId) {
+  const script = `
+    tell application "Reminders"
+      set allLists to lists
+      repeat with theList in allLists
+        try
+          set theReminder to reminder id "${escapeAppleScript(reminderId)}" of theList
+          delete theReminder
+          return "deleted"
+        end try
+      end repeat
+      return "not found"
+    end tell
+  `;
+
+  const result = await runAppleScript(script);
+  if (result === 'not found') {
+    return { success: false, message: 'Reminder not found' };
+  }
+  return { success: true, message: 'Reminder deleted successfully' };
+}
+
+/**
+ * Search reminders
+ * @param {string} query - Search query
+ * @param {number} count - Max results
+ * @returns {Promise<Array>} - Matching reminders
+ */
+async function searchReminders(query, count = 25) {
+  const searchTerm = escapeJXA(query.toLowerCase());
+  const limit = asInt(count, 25);
+
+  const script = `
+    const reminders = Application('Reminders');
+    const lists = reminders.lists();
+    let results = [];
+
+    for (let list of lists) {
+      const rems = list.reminders();
+      for (let r of rems) {
+        if (results.length >= ${limit}) break;
+
+        const name = (r.name() || '').toLowerCase();
+        const body = (r.body() || '').toLowerCase();
+
+        if (name.includes("${searchTerm}") || body.includes("${searchTerm}")) {
+          results.push({
+            id: r.id(),
+            name: r.name(),
+            body: r.body() || '',
+            completed: r.completed(),
+            dueDate: r.dueDate() ? r.dueDate().toISOString() : null,
+            priority: r.priority(),
+            list: list.name()
+          });
+        }
+      }
+    }
+
+    JSON.stringify(results);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+module.exports = {
+  listReminderLists,
+  listReminders,
+  createReminder,
+  updateReminder,
+  completeReminder,
+  deleteReminder,
+  searchReminders
+};

package/safari/index.js

@@ -0,0 +1,122 @@
+/**
+ * Safari Module
+ * MCP tool definitions for Safari.app
+ */
+
+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');
+
+function requireLocalMode(toolName) {
+  if (!isLocalMode()) {
+    return formatError(new Error(`${toolName} is only available in LOCAL mode. Use set-mode to switch.`));
+  }
+  return null;
+}
+
+const safariTools = [
+  {
+    name: 'list-safari-tabs',
+    outputSchema: listOutput('list-safari-tabs'),
+    title: 'List Safari Tabs',
+    description: 'Lists all open tabs in Safari across all windows',
+    inputSchema: {},
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async () => {
+      const modeError = requireLocalMode('list-safari-tabs');
+      if (modeError) return modeError;
+
+      try {
+        const tabs = await localClient.listTabs();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(tabs, null, 2)
+          }],
+          structuredContent: listResult(tabs)
+        };
+      } catch (error) {
+        return formatError(error, 'list-safari-tabs');
+      }
+    }
+  },
+  {
+    name: 'get-current-safari-url',
+    title: 'Get Current Safari URL',
+    description: 'Gets the URL and title of the current/active Safari tab',
+    inputSchema: {},
+    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async () => {
+      const modeError = requireLocalMode('get-current-safari-url');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.getCurrentUrl();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'get-current-safari-url');
+      }
+    }
+  },
+  {
+    name: 'open-safari-url',
+    title: 'Open URL In Safari',
+    description: 'Opens a URL in Safari (new tab or new window)',
+    inputSchema: {
+      url: z.string().describe('URL to open (required)'),
+      inNewWindow: z.boolean().optional().describe('Open in new window instead of new tab (default: false)')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":false,"openWorldHint":true},
+    handler: async ({ url, inNewWindow = false }) => {
+      const modeError = requireLocalMode('open-safari-url');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.openUrl(url, inNewWindow);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'open-safari-url');
+      }
+    }
+  },
+  {
+    name: 'close-safari-tab',
+    title: 'Close Safari Tab',
+    description: 'Closes a Safari tab',
+    inputSchema: {
+      windowIndex: z.number().int().min(0).optional().describe('Window index (0-based, default: 0 for front window)'),
+      tabIndex: z.number().int().min(0).optional().describe('Tab index to close (0-based). If omitted, closes the current tab.')
+    },
+    annotations: {"readOnlyHint":false,"destructiveHint":true,"idempotentHint":true,"openWorldHint":false},
+    handler: async ({ windowIndex = 0, tabIndex }) => {
+      const modeError = requireLocalMode('close-safari-tab');
+      if (modeError) return modeError;
+
+      try {
+        const result = await localClient.closeTab(windowIndex, tabIndex);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      } catch (error) {
+        return formatError(error, 'close-safari-tab');
+      }
+    }
+  }
+];
+
+module.exports = { safariTools };

package/safari/local-client.js

@@ -0,0 +1,156 @@
+/**
+ * Local Safari Client
+ * Accesses Safari.app via AppleScript
+ */
+
+const { runAppleScript, runJXA, escapeAppleScript, escapeJXA, asInt } = require('../utils/applescript');
+
+/**
+ * List all open tabs across all windows
+ * @returns {Promise<Array>} - List of tabs
+ */
+async function listTabs() {
+  const script = `
+    const safari = Application('Safari');
+    const windows = safari.windows();
+    let tabs = [];
+
+    for (let i = 0; i < windows.length; i++) {
+      const win = windows[i];
+      try {
+        const winTabs = win.tabs();
+        for (let j = 0; j < winTabs.length; j++) {
+          const tab = winTabs[j];
+          tabs.push({
+            windowIndex: i,
+            tabIndex: j,
+            name: tab.name(),
+            url: tab.url(),
+            isCurrent: win.currentTab().index() === tab.index()
+          });
+        }
+      } catch (e) {}
+    }
+
+    JSON.stringify(tabs);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * Get the current/active tab URL
+ * @returns {Promise<Object>} - Current tab info
+ */
+async function getCurrentUrl() {
+  const script = `
+    const safari = Application('Safari');
+    const frontWindow = safari.windows[0];
+    const currentTab = frontWindow.currentTab();
+
+    JSON.stringify({
+      name: currentTab.name(),
+      url: currentTab.url(),
+      source: currentTab.source ? currentTab.source().substring(0, 1000) : null
+    });
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : null;
+}
+
+/**
+ * Open a URL in a new tab
+ * @param {string} url - URL to open
+ * @param {boolean} inNewWindow - Open in new window instead of new tab
+ * @returns {Promise<Object>} - Result
+ */
+async function openUrl(url, inNewWindow = false) {
+  // Ensure URL has protocol
+  let fullUrl = url;
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    fullUrl = 'https://' + url;
+  }
+
+  if (inNewWindow) {
+    const script = `
+      tell application "Safari"
+        make new document with properties {URL:"${escapeAppleScript(fullUrl)}"}
+        activate
+      end tell
+      return "opened"
+    `;
+    await runAppleScript(script);
+  } else {
+    const script = `
+      tell application "Safari"
+        tell front window
+          set newTab to make new tab with properties {URL:"${escapeAppleScript(fullUrl)}"}
+          set current tab to newTab
+        end tell
+        activate
+      end tell
+      return "opened"
+    `;
+    await runAppleScript(script);
+  }
+
+  return { success: true, message: `Opened ${fullUrl}` };
+}
+
+/**
+ * Close a tab
+ * @param {number} windowIndex - Window index
+ * @param {number} tabIndex - Tab index
+ * @returns {Promise<Object>} - Result
+ */
+async function closeTab(windowIndex = 0, tabIndex = null) {
+  if (tabIndex !== null && tabIndex !== undefined) {
+    const script = `
+      tell application "Safari"
+        tell window ${asInt(windowIndex, 0) + 1}
+          close tab ${asInt(tabIndex, 0) + 1}
+        end tell
+      end tell
+      return "closed"
+    `;
+    await runAppleScript(script);
+  } else {
+    // Close current tab
+    const script = `
+      tell application "Safari"
+        tell front window
+          close current tab
+        end tell
+      end tell
+      return "closed"
+    `;
+    await runAppleScript(script);
+  }
+
+  return { success: true, message: 'Tab closed' };
+}
+
+/**
+ * Get the reading list items
+ * Note: This requires parsing Safari's bookmarks plist
+ * @returns {Promise<Array>} - Reading list items
+ */
+async function getReadingList() {
+  // Reading list is stored in ~/Library/Safari/Bookmarks.plist
+  // This requires parsing a binary plist which is complex
+  // For now, return a note about this limitation
+  return {
+    message: 'Reading list access requires parsing Safari bookmarks plist. Use Safari directly for reading list management.',
+    items: []
+  };
+}
+
+module.exports = {
+  listTabs,
+  getCurrentUrl,
+  openUrl,
+  closeTab,
+  getReadingList
+};