icloud-mcp 2.5.0 → 2.7.0

package/lib/reminders.js

@@ -0,0 +1,316 @@
+// ─── lib/reminders.js — iCloud Reminders via JXA (JavaScript for Automation) ──
+//
+// Uses `osascript -l JavaScript` to talk directly to Reminders.app, bypassing
+// the broken CalDAV VTODO endpoint (Apple moved modern Reminders to CloudKit,
+// which is not exposed via standard CalDAV).
+//
+// PERMISSION: The first time Node.js calls osascript on Reminders, macOS will
+// show an Automation permission dialog. Run `node -e "require('./lib/reminders.js')"
+// manually once to grant permission, then it persists for headless digest runs.
+
+import { execFileSync } from 'child_process';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const PRIORITY_FROM_JXA = { 0: 'none', 1: 'high', 2: 'high', 3: 'high', 4: 'high', 5: 'medium', 6: 'low', 7: 'low', 8: 'low', 9: 'low' };
+const PRIORITY_TO_JXA   = { none: 0, high: 1, medium: 5, low: 9 };
+
+// ─── JXA runner ───────────────────────────────────────────────────────────────
+
+// Reminders.app can stall for 30s+ right after a burst of changes while it syncs.
+const JXA_TIMEOUT_MS = 90_000;
+
+function runJxaImpl(script) {
+  const tmpFile = join(tmpdir(), `jxa-${randomUUID()}.js`);
+  writeFileSync(tmpFile, script, 'utf8');
+  try {
+    const output = execFileSync('osascript', ['-l', 'JavaScript', tmpFile], {
+      timeout: JXA_TIMEOUT_MS,
+      encoding: 'utf8',
+    });
+    return output.trim();
+  } catch (err) {
+    // execFileSync kills the script at the timeout. Say so plainly: the generic
+    // ETIMEDOUT text would otherwise be reported as an iCloud network timeout.
+    if (err.code === 'ETIMEDOUT' || err.signal === 'SIGTERM') {
+      throw new Error(
+        `Reminders script timed out after ${JXA_TIMEOUT_MS / 1000}s. Reminders.app is slow to respond, often while it syncs. ` +
+        'If this was a create, update, rename, or delete, it may still have gone through: check before retrying.'
+      );
+    }
+    const stderr = (err.stderr || '').toString();
+    if (stderr.includes('not allowed') || stderr.includes('Authorization') || stderr.includes('assistive access')) {
+      throw new Error(
+        'Reminders access not authorized. Run this once in Terminal to grant permission:\n' +
+        '  osascript -l JavaScript -e \'Application("Reminders").lists.length\'\n' +
+        'Then click Allow in the dialog.'
+      );
+    }
+    const msg = stderr.replace(/\n/g, ' ').trim() || err.message;
+    throw new Error(`JXA error: ${msg}`);
+  } finally {
+    try { unlinkSync(tmpFile); } catch {}
+  }
+}
+
+// JXA returns a bare value for one match and sometimes null for none. Callers index these as arrays.
+export function asArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+// Shared helper embedded in JXA scripts — finds a reminder within a list by ID.
+const JXA_FIND_HELPER = `
+${asArray.toString()}
+// Uses a whose() query: one Apple Event, instead of one per reminder in the list.
+function findReminder(list, id) {
+  const matches = asArray(list.reminders.whose({ id: id })());
+  if (matches.length === 0) throw new Error('Reminder not found: ' + id);
+  return matches[0];
+}
+`;
+
+let jxaRunner = runJxaImpl;
+
+export function setJxaRunnerForTests(fn) {
+  jxaRunner = fn || runJxaImpl;
+}
+
+function runJxa(script) {
+  return jxaRunner(script);
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export function listReminderLists() {
+  const result = runJxa(`
+    const app = Application('Reminders');
+    const lists = app.lists().map(l => ({
+      id: l.id(),
+      name: l.name(),
+      count: l.reminders.length,
+    }));
+    JSON.stringify({ lists, count: lists.length });
+  `);
+  return JSON.parse(result);
+}
+
+export function listReminders(listName = null, includeCompleted = false, limit = 50) {
+  const result = runJxa(`
+    ${asArray.toString()}
+    const app = Application('Reminders');
+    const listName = ${JSON.stringify(listName)};
+    const includeCompleted = ${JSON.stringify(includeCompleted)};
+    const limit = ${JSON.stringify(limit)};
+    const priorityMap = ${JSON.stringify(PRIORITY_FROM_JXA)};
+
+    const lists = listName ? [app.lists.byName(listName)] : app.lists();
+    const reminders = [];
+
+    // Read each property for the whole list in one Apple Event. Reading them per
+    // reminder costs one round trip each and blew the 30s timeout on a 38-item list.
+    // A one-item collection comes back as a single value, and an empty one as null.
+    const iso = (d) => (d ? d.toISOString() : null);
+    for (const list of lists) {
+      const spec = includeCompleted ? list.reminders : list.reminders.whose({ completed: false });
+      const ids = asArray(spec.id());
+      if (ids.length === 0) continue;
+      const names = asArray(spec.name());
+      const bodies = asArray(spec.body());
+      const completed = asArray(spec.completed());
+      const dues = asArray(spec.dueDate());
+      const completedAts = asArray(spec.completionDate());
+      const priorities = asArray(spec.priority());
+      const createdAts = asArray(spec.creationDate());
+      const modifiedAts = asArray(spec.modificationDate());
+      const columns = [names, bodies, completed, dues, completedAts, priorities, createdAts, modifiedAts];
+      if (columns.some((col) => col.length !== ids.length)) {
+        throw new Error('Reminder property batches differ in length');
+      }
+      const thisListName = list.name();
+      const thisListId = list.id();
+      for (let i = 0; i < ids.length && reminders.length < limit; i++) {
+        reminders.push({
+          id: ids[i],
+          title: names[i],
+          notes: bodies[i] || null,
+          completed: completed[i],
+          due: iso(dues[i]),
+          completedAt: iso(completedAts[i]),
+          priority: priorityMap[String(priorities[i])] || 'none',
+          listName: thisListName,
+          listId: thisListId,
+          createdAt: iso(createdAts[i]),
+          modifiedAt: iso(modifiedAts[i]),
+        });
+      }
+      if (reminders.length >= limit) break;
+    }
+
+    JSON.stringify({ reminders, count: reminders.length, listName, includeCompleted });
+  `);
+  return JSON.parse(result);
+}
+
+export function getReminder(listName, reminderId) {
+  const result = runJxa(`
+    ${JXA_FIND_HELPER}
+    const app = Application('Reminders');
+    const list = app.lists.byName(${JSON.stringify(listName)});
+    const r = findReminder(list, ${JSON.stringify(reminderId)});
+    const priorityMap = ${JSON.stringify(PRIORITY_FROM_JXA)};
+    JSON.stringify({
+      id: r.id(),
+      title: r.name(),
+      notes: r.body() || null,
+      completed: r.completed(),
+      due: r.dueDate() ? r.dueDate().toISOString() : null,
+      completedAt: r.completionDate() ? r.completionDate().toISOString() : null,
+      priority: priorityMap[String(r.priority())] || 'none',
+      listName: list.name(),
+      listId: list.id(),
+      createdAt: r.creationDate() ? r.creationDate().toISOString() : null,
+      modifiedAt: r.modificationDate() ? r.modificationDate().toISOString() : null,
+    });
+  `);
+  return JSON.parse(result);
+}
+
+export function createReminder(listName, fields) {
+  const priorityVal = PRIORITY_TO_JXA[fields.priority] ?? 0;
+  const result = runJxa(`
+    const app = Application('Reminders');
+    const list = app.lists.byName(${JSON.stringify(listName)});
+    const props = { name: ${JSON.stringify(fields.title || '(No title)')} };
+    ${fields.notes !== undefined ? `props.body = ${JSON.stringify(fields.notes)};` : ''}
+    ${fields.due !== undefined ? `props.dueDate = new Date(${JSON.stringify(fields.due)});` : ''}
+    ${priorityVal ? `props.priority = ${priorityVal};` : ''}
+    const r = app.make({ new: 'reminder', at: list, withProperties: props });
+    JSON.stringify({ created: true, id: r.id(), listName: list.name() });
+  `);
+  return JSON.parse(result);
+}
+
+export function updateReminder(listName, reminderId, fields) {
+  const priorityVal = fields.priority !== undefined ? (PRIORITY_TO_JXA[fields.priority] ?? 0) : null;
+  const result = runJxa(`
+    ${JXA_FIND_HELPER}
+    const app = Application('Reminders');
+    const list = app.lists.byName(${JSON.stringify(listName)});
+    const r = findReminder(list, ${JSON.stringify(reminderId)});
+    ${fields.title !== undefined ? `r.name = ${JSON.stringify(fields.title)};` : ''}
+    ${fields.notes !== undefined ? `r.body = ${JSON.stringify(fields.notes)};` : ''}
+    ${fields.due !== undefined ? `r.dueDate = new Date(${JSON.stringify(fields.due)});` : ''}
+    ${priorityVal !== null ? `r.priority = ${priorityVal};` : ''}
+    JSON.stringify({ updated: true, id: r.id() });
+  `);
+  return JSON.parse(result);
+}
+
+export function completeReminder(listName, reminderId) {
+  const result = runJxa(`
+    ${JXA_FIND_HELPER}
+    const app = Application('Reminders');
+    const list = app.lists.byName(${JSON.stringify(listName)});
+    const r = findReminder(list, ${JSON.stringify(reminderId)});
+    r.completed = true;
+    JSON.stringify({ updated: true, id: r.id(), completed: true });
+  `);
+  return JSON.parse(result);
+}
+
+export function deleteReminder(listName, reminderId, dryRun = false) {
+  if (dryRun) {
+    const existing = getReminder(listName, reminderId);
+    return {
+      dryRun: true,
+      wouldDelete: true,
+      changes: [{
+        action: 'delete_reminder',
+        listName,
+        reminderId,
+        title: existing.title,
+        notes: existing.notes,
+        due: existing.due,
+      }],
+    };
+  }
+  const result = runJxa(`
+    ${JXA_FIND_HELPER}
+    const app = Application('Reminders');
+    const list = app.lists.byName(${JSON.stringify(listName)});
+    const r = findReminder(list, ${JSON.stringify(reminderId)});
+    app.delete(r);
+    JSON.stringify({ deleted: true, id: ${JSON.stringify(reminderId)} });
+  `);
+  return JSON.parse(result);
+}
+
+export function createReminderList(name) {
+  const result = runJxa(`
+    const app = Application('Reminders');
+    const name = ${JSON.stringify(name)};
+    if (app.lists().some(l => l.name() === name)) throw new Error('A list named "' + name + '" already exists');
+    const list = app.make({ new: 'list', withProperties: { name } });
+    JSON.stringify({ created: true, id: list.id(), name: list.name() });
+  `);
+  return JSON.parse(result);
+}
+
+// Refuses to delete a list that still has reminders in it, the same rule
+// delete_mailbox follows. Delete or move the reminders first.
+export function deleteReminderList(name, dryRun = false) {
+  const result = runJxa(`
+    const app = Application('Reminders');
+    const name = ${JSON.stringify(name)};
+    const dryRun = ${JSON.stringify(dryRun)};
+    const matches = app.lists().filter(l => l.name() === name);
+    if (matches.length === 0) throw new Error('Reminder list not found: ' + name);
+    if (matches.length > 1) throw new Error('More than one list is named "' + name + '"; refusing to guess which to delete');
+    const list = matches[0];
+    const id = list.id();
+    const reminderCount = list.reminders.length;
+    let out;
+    if (dryRun) {
+      out = {
+        dryRun: true,
+        wouldDelete: reminderCount === 0,
+        changes: reminderCount === 0 ? [{ action: 'delete_reminder_list', name, id, reminderCount }] : [],
+        reminderCount,
+      };
+    } else {
+      if (reminderCount > 0) throw new Error('List "' + name + '" still has ' + reminderCount + ' reminder(s); delete them first');
+      app.delete(list);
+      out = { deleted: true, name, id };
+    }
+    JSON.stringify(out);
+  `);
+  return JSON.parse(result);
+}
+
+export function renameReminderList(oldName, newName, dryRun = false) {
+  const result = runJxa(`
+    const app = Application('Reminders');
+    const oldName = ${JSON.stringify(oldName)};
+    const newName = ${JSON.stringify(newName)};
+    const dryRun = ${JSON.stringify(dryRun)};
+    const all = app.lists();
+    const matches = all.filter(l => l.name() === oldName);
+    if (matches.length === 0) throw new Error('Reminder list not found: ' + oldName);
+    if (matches.length > 1) throw new Error('More than one list is named "' + oldName + '"; refusing to guess which to rename');
+    if (all.some(l => l.name() === newName)) throw new Error('A list named "' + newName + '" already exists');
+    const list = matches[0];
+    const id = list.id();
+    let out;
+    if (dryRun) {
+      out = { dryRun: true, changes: [{ action: 'rename_reminder_list', id, from: oldName, to: newName }] };
+    } else {
+      list.name = newName;
+      out = { renamed: true, id, from: oldName, to: list.name() };
+    }
+    JSON.stringify(out);
+  `);
+  return JSON.parse(result);
+}

package/lib/session.js

@@ -1,14 +1,16 @@
 // ─── Session Log ──────────────────────────────────────────────────────────────
 import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
+import { dataFile } from './data-paths.js';
 
-const LOG_FILE = join(homedir(), '.icloud-mcp-session.json');
+function logFile() {
+  return dataFile('.icloud-mcp-session.json');
+}
 
 export function logRead() {
-  if (!existsSync(LOG_FILE)) return { steps: [], startedAt: null };
+  const file = logFile();
+  if (!existsSync(file)) return { steps: [], startedAt: null };
   try {
-    return JSON.parse(readFileSync(LOG_FILE, 'utf8'));
+    return JSON.parse(readFileSync(file, 'utf8'));
   } catch {
     return { steps: [], startedAt: null };
   }
@@ -18,11 +20,11 @@ export function logWrite(step) {
   const log = logRead();
   if (!log.startedAt) log.startedAt = new Date().toISOString();
   log.steps.push({ time: new Date().toISOString(), step });
-  writeFileSync(LOG_FILE, JSON.stringify(log, null, 2));
+  writeFileSync(logFile(), JSON.stringify(log, null, 2));
   return log;
 }
 
 export function logClear() {
-  writeFileSync(LOG_FILE, JSON.stringify({ steps: [], startedAt: null }, null, 2));
+  writeFileSync(logFile(), JSON.stringify({ steps: [], startedAt: null }, null, 2));
   return { cleared: true };
 }

package/lib/smtp.js

@@ -28,6 +28,35 @@ function normalizeAddresses(val) {
   return Array.isArray(val) ? val.join(', ') : val;
 }
 
+// Compare mailbox addresses ignoring case, surrounding whitespace, and a display name.
+export function normalizeMailboxAddress(value) {
+  const text = String(value ?? '').trim().toLowerCase();
+  const angled = text.match(/<([^>]+)>/);
+  return (angled ? angled[1] : text).trim();
+}
+
+// Recipients replyToEmail will put in To.
+// Reply-all drops the account when anyone else is on the message (same as before).
+// A message whose only party is the account still replies to the account, so a
+// self-seed is not sent with an empty To.
+export function planReplyAddresses(email, account, replyAll = false) {
+  const user = normalizeMailboxAddress(account);
+  const replyTarget = email?.headers?.replyTo || email?.from || '';
+  if (!replyAll) return replyTarget ? [replyTarget] : [];
+
+  const parties = [replyTarget, ...(email?.headers?.to || []), ...(email?.headers?.cc || [])].filter(Boolean);
+  const others = [];
+  const seen = new Set();
+  for (const party of parties) {
+    const key = normalizeMailboxAddress(party);
+    if (!key || key === user || seen.has(key)) continue;
+    seen.add(key);
+    others.push(party);
+  }
+  if (others.length === 0) return user ? [account] : [];
+  return others;
+}
+
 // Convert HTML to a readable plain-text fallback for multipart/alternative
 function htmlToText(html) {
   return html
@@ -90,30 +119,19 @@ export async function replyToEmail(email, body, opts = {}, creds = null) {
 
   const originalSubject   = email.subject ?? '';
   const originalMessageId = email.headers?.messageId ?? null;
-  const originalFrom      = email.from ?? '';
-  const originalReplyTo   = email.headers?.replyTo ?? null;
   const existingRefs      = email.headers?.references ?? [];
 
-  const subject = /^re:/i.test(originalSubject) ? originalSubject : `Re: ${originalSubject}`;
+  const subject = /^(re|in re):\s/i.test(originalSubject) || /^(re|in re):\s/i.test(originalSubject.replace(/^\[EXTERNAL\]\s*/i, ''))
+    ? originalSubject
+    : `Re: ${originalSubject}`;
 
   // Build RFC 2822 References chain: existing refs + original message-id
   const references = [...existingRefs, ...(originalMessageId ? [originalMessageId] : [])]
     .filter(Boolean)
     .join(' ');
 
-  // Who to reply to: prefer Reply-To over From
-  const replyTarget = originalReplyTo ?? originalFrom;
-
-  let toAddresses;
-  if (opts.replyAll) {
-    const originalTo = email.headers?.to  ?? [];
-    const originalCc = email.headers?.cc  ?? [];
-    // Reply-all: reply target + original To/Cc, excluding ourselves
-    toAddresses = [replyTarget, ...originalTo, ...originalCc]
-      .filter(a => a && a !== user);
-  } else {
-    toAddresses = [replyTarget].filter(Boolean);
-  }
+  // Prefer Reply-To over From. A self-only thread replies to the account.
+  const toAddresses = planReplyAddresses(email, user, Boolean(opts.replyAll));
 
   const mailOptions = {
     from: user,
@@ -170,6 +188,15 @@ export async function forwardEmail(email, to, note = '', opts = {}, creds = null
   };
 }
 
+// ImapFlow emits 'error' on socket timeouts. With no listener, Node treats it as
+// an uncaught exception and the server exits.
+export function attachImapErrorHandler(client) {
+  client.on('error', (err) => {
+    process.stderr.write(`[imap] connection error: ${err?.message ?? err}\n`);
+  });
+  return client;
+}
+
 // ─── save_draft ───────────────────────────────────────────────────────────────
 // Builds the raw MIME message without sending, then APPENDs to Drafts via IMAP.
 
@@ -178,15 +205,19 @@ export async function saveDraft(to, subject, body, opts = {}, creds = null) {
 
   const mailOptions = { from: user, to: normalizeAddresses(to), subject };
   applyBody(mailOptions, body, opts.html);
-  if (opts.cc)  mailOptions.cc  = normalizeAddresses(opts.cc);
-  if (opts.bcc) mailOptions.bcc = normalizeAddresses(opts.bcc);
+  if (opts.cc)        mailOptions.cc        = normalizeAddresses(opts.cc);
+  if (opts.bcc)       mailOptions.bcc       = normalizeAddresses(opts.bcc);
+  if (opts.inReplyTo) mailOptions.inReplyTo = opts.inReplyTo;
+  if (opts.references) mailOptions.references = Array.isArray(opts.references)
+    ? opts.references.join(' ')
+    : opts.references;
 
   // Use nodemailer stream transport to produce raw MIME bytes without sending
   const streamTransport = nodemailer.createTransport({ streamTransport: true, buffer: true });
   const { message: rawMessage } = await streamTransport.sendMail(mailOptions);
 
   // APPEND the raw message to the Drafts folder via IMAP
-  const client = new ImapFlow({
+  const client = attachImapErrorHandler(new ImapFlow({
     host: imapHost,
     port: 993,
     secure: true,
@@ -195,7 +226,7 @@ export async function saveDraft(to, subject, body, opts = {}, creds = null) {
     connectionTimeout: 15_000,
     greetingTimeout: 15_000,
     socketTimeout: 60_000,
-  });
+  }));
 
   await client.connect();
 
@@ -204,7 +235,8 @@ export async function saveDraft(to, subject, body, opts = {}, creds = null) {
     await client.append(draftMailbox, rawMessage, ['\\Draft', '\\Seen']);
   } catch (err) {
     // Folder might have a different name — scan the list for the \Drafts attribute
-    if (err.message?.includes('NONEXISTENT') || err.message?.includes('does not exist') || err.message?.includes('NO ')) {
+    const r = err.responseText ?? err.message ?? '';
+    if (r.includes('NONEXISTENT') || r.includes('does not exist') || r.includes("doesn't exist") || r.includes('TRYCREATE') || r.includes('NO ') || r.includes('Failure')) {
       const mailboxes = await client.list();
       const draftMb = mailboxes.find(mb => mb.flags?.has('\\Drafts'));
       draftMailbox = draftMb?.path ?? 'Drafts';