icloud-mcp 2.3.0 → 2.5.0

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"583b9a47-29dc-4265-b2f0-dc31dbbd06c3","pid":81825,"acquiredAt":1773517693304}

package/index.js

@@ -20,6 +20,7 @@ import {
 import { logRead, logWrite, logClear } from './lib/session.js';
 import { composeEmail, replyToEmail, forwardEmail, saveDraft } from './lib/smtp.js';
 import { listContacts, searchContacts, getContact, createContact, updateContact, deleteContact } from './lib/carddav.js';
+import { getDigestState, updateDigestState } from './lib/digest.js';
 import { formatEmailForExtraction } from './lib/event-extractor.js';
 import { listCalendars, listEvents, getEvent, createEvent, updateEvent, deleteEvent, searchEvents } from './lib/caldav.js';
 
@@ -35,11 +36,59 @@ if (!IMAP_USER || !IMAP_PASSWORD) {
   }
 }
 
+// ─── Multi-account support ────────────────────────────────────────────────────
+// Configure additional accounts via numbered env vars:
+//   IMAP_ACCOUNT_1_USER, IMAP_ACCOUNT_1_PASSWORD, IMAP_ACCOUNT_1_HOST,
+//   IMAP_ACCOUNT_1_SMTP_HOST, IMAP_ACCOUNT_1_NAME
+// Falls back to IMAP_USER / IMAP_PASSWORD (iCloud) when no numbered accounts set.
+
+function parseAccounts() {
+  const accounts = {};
+  for (let i = 1; i <= 10; i++) {
+    const user = process.env[`IMAP_ACCOUNT_${i}_USER`];
+    const pass = process.env[`IMAP_ACCOUNT_${i}_PASSWORD`];
+    if (!user || !pass) continue;
+    const host     = process.env[`IMAP_ACCOUNT_${i}_HOST`]      || 'imap.mail.me.com';
+    const smtpHost = process.env[`IMAP_ACCOUNT_${i}_SMTP_HOST`] || 'smtp.mail.me.com';
+    const name     = process.env[`IMAP_ACCOUNT_${i}_NAME`]      || `account${i}`;
+    accounts[name] = { user, pass, host, smtpHost };
+  }
+  // Legacy fallback — single iCloud account via IMAP_USER / IMAP_PASSWORD
+  if (Object.keys(accounts).length === 0 && IMAP_USER) {
+    accounts['icloud'] = { user: IMAP_USER, pass: IMAP_PASSWORD, host: 'imap.mail.me.com', smtpHost: 'smtp.mail.me.com' };
+  }
+  return accounts;
+}
+
+const ACCOUNTS = parseAccounts();
+const DEFAULT_ACCOUNT = Object.keys(ACCOUNTS)[0] || 'icloud';
+
+function resolveCreds(account) {
+  const name = account || DEFAULT_ACCOUNT;
+  const creds = ACCOUNTS[name];
+  if (!creds) throw new Error(`Account '${name}' not configured. Available: ${Object.keys(ACCOUNTS).join(', ') || 'none'}`);
+  return creds;
+}
+
+// Gmail uses different folder names than iCloud for system folders.
+const GMAIL_MAILBOX_MAP = {
+  'Sent Messages':   '[Gmail]/Sent Mail',
+  'Archive':         '[Gmail]/All Mail',
+  'Deleted Messages':'[Gmail]/Trash',
+  'Junk':            '[Gmail]/Spam',
+  'Drafts':          '[Gmail]/Drafts',
+};
+
+function resolveMailbox(name, creds) {
+  if (!name || creds?.host !== 'imap.gmail.com') return name;
+  return GMAIL_MAILBOX_MAP[name] || name;
+}
+
 // ─── MCP Server ───────────────────────────────────────────────────────────────
 
 async function main() {
   const server = new Server(
-    { name: 'icloud-mail', version: '2.3.0' },
+    { name: 'icloud-mail', version: '2.5.0' },
     { capabilities: { tools: {} } }
   );
 
@@ -53,15 +102,22 @@ async function main() {
     flagged: { type: 'boolean', description: 'True for flagged only, false for unflagged only' },
     larger: { type: 'number', description: 'Only emails larger than this size in KB' },
     smaller: { type: 'number', description: 'Only emails smaller than this size in KB' },
-    hasAttachment: { type: 'boolean', description: 'Only emails with attachments (client-side BODYSTRUCTURE scan — must be combined with other filters that narrow results to under 500 emails first)' }
+    hasAttachment: { type: 'boolean', description: 'Only emails with attachments (client-side BODYSTRUCTURE scan — must be combined with other filters that narrow results to under 500 emails first)' },
+    account: { type: 'string', description: "Account name to use (e.g. 'icloud', 'gmail'). Defaults to first configured account. Use list_accounts to see available accounts." }
   };
+  const accountSchema = filtersSchema.account;
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
+      {
+        name: 'list_accounts',
+        description: 'List all configured email accounts (names and IMAP hosts). Use the account name in any mail tool\'s account parameter.',
+        inputSchema: { type: 'object', properties: {} }
+      },
       {
         name: 'get_inbox_summary',
         description: 'Get a summary of a mailbox including total, unread, and recent email counts',
-        inputSchema: { type: 'object', properties: { mailbox: { type: 'string', description: 'Mailbox name (default INBOX)' } } }
+        inputSchema: { type: 'object', properties: { mailbox: { type: 'string', description: 'Mailbox name (default INBOX)' }, account: accountSchema } }
       },
       {
         name: 'get_mailbox_summary',
@@ -677,6 +733,25 @@ async function main() {
           required: ['to', 'subject']
         }
       },
+      // ── Digest State ──
+      {
+        name: 'get_digest_state',
+        description: 'Get the current inbox digest state — last run timestamp, processed email UIDs (to skip on next run), pending actions, and per-sender skip counts for smart unsubscribe.',
+        inputSchema: { type: 'object', properties: {} }
+      },
+      {
+        name: 'update_digest_state',
+        description: 'Update the digest state after a run. Merges new processed UIDs into the existing list, updates lastRun, replaces pendingActions, and accumulates per-sender skip counts.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            lastRun: { type: 'string', description: 'ISO timestamp of this run' },
+            processedUids: { type: 'array', items: { type: 'number' }, description: 'Email UIDs processed in this run — merged with existing and capped at 5000' },
+            pendingActions: { type: 'array', description: 'Full replacement list of pending action items to track across runs (deadlines, waiting-for-reply, etc.). Each item: { type, subject, to/from, dueDate?, notes? }' },
+            skipCounts: { type: 'object', description: 'Map of sender address to skip count increment for this run, e.g. { "bestbuy@email.bestbuy.com": 3 }. Accumulated across runs for smart unsubscribe.' }
+          }
+        }
+      },
       // ── CardDAV / Contacts ──
       {
         name: 'list_contacts',
@@ -886,94 +961,134 @@ async function main() {
     const { name, arguments: args } = request.params;
     try {
       let result;
+      // ── Account listing (no creds needed) ──
+      if (name === 'list_accounts') {
+        result = Object.entries(ACCOUNTS).map(([n, c]) => ({ name: n, host: c.host, smtpHost: c.smtpHost }));
       // ── Metadata tier (15s) ──
-      if (name === 'get_inbox_summary') {
-        result = await withTimeout('get_inbox_summary', TIMEOUT.METADATA, () => getInboxSummary(args.mailbox || 'INBOX'));
+      } else if (name === 'get_inbox_summary') {
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_inbox_summary', TIMEOUT.METADATA, () => getInboxSummary(args.mailbox || 'INBOX', creds));
       } else if (name === 'get_mailbox_summary') {
-        result = await withTimeout('get_mailbox_summary', TIMEOUT.METADATA, () => getMailboxSummary(args.mailbox));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_mailbox_summary', TIMEOUT.METADATA, () => getMailboxSummary(resolveMailbox(args.mailbox, creds), creds));
       } else if (name === 'count_emails') {
-        const { mailbox, ...filters } = args;
-        result = await withTimeout('count_emails', TIMEOUT.METADATA, () => countEmails(filters, mailbox || 'INBOX'));
+        const { mailbox, account, ...filters } = args;
+        const creds = resolveCreds(account);
+        result = await withTimeout('count_emails', TIMEOUT.METADATA, () => countEmails(filters, mailbox || 'INBOX', creds));
       } else if (name === 'list_mailboxes') {
-        result = await withTimeout('list_mailboxes', TIMEOUT.METADATA, () => listMailboxes());
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('list_mailboxes', TIMEOUT.METADATA, () => listMailboxes(creds));
       } else if (name === 'create_mailbox') {
-        result = await withTimeout('create_mailbox', TIMEOUT.METADATA, () => createMailbox(args.name));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('create_mailbox', TIMEOUT.METADATA, () => createMailbox(args.name, creds));
       } else if (name === 'rename_mailbox') {
-        result = await renameMailbox(args.oldName, args.newName); // already has its own 15s timeout
+        const creds = resolveCreds(args.account);
+        result = await renameMailbox(args.oldName, args.newName, creds); // already has its own 15s timeout
       } else if (name === 'delete_mailbox') {
-        result = await deleteMailbox(args.name); // already has its own 15s timeout
+        const creds = resolveCreds(args.account);
+        result = await deleteMailbox(args.name, creds); // already has its own 15s timeout
       // ── Fetch tier (30s) ──
       } else if (name === 'read_inbox') {
-        result = await withTimeout('read_inbox', TIMEOUT.FETCH, () => fetchEmails(args.mailbox || 'INBOX', args.limit || 10, args.onlyUnread || false, args.page || 1));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('read_inbox', TIMEOUT.FETCH, () => fetchEmails(args.mailbox || 'INBOX', args.limit || 10, args.onlyUnread || false, args.page || 1, creds));
       } else if (name === 'get_email') {
-        result = await withTimeout('get_email', TIMEOUT.FETCH, () => getEmailContent(args.uid, args.mailbox || 'INBOX', args.maxChars || 8000, args.includeHeaders || false));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_email', TIMEOUT.FETCH, () => getEmailContent(args.uid, args.mailbox || 'INBOX', args.maxChars || 8000, args.includeHeaders || false, creds));
       } else if (name === 'list_attachments') {
-        result = await withTimeout('list_attachments', TIMEOUT.FETCH, () => listAttachments(args.uid, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('list_attachments', TIMEOUT.FETCH, () => listAttachments(args.uid, args.mailbox || 'INBOX', creds));
       } else if (name === 'get_attachment') {
-        result = await withTimeout('get_attachment', TIMEOUT.FETCH, () => getAttachment(args.uid, args.partId, args.mailbox || 'INBOX', args.offset ?? null, args.length ?? null));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_attachment', TIMEOUT.FETCH, () => getAttachment(args.uid, args.partId, args.mailbox || 'INBOX', args.offset ?? null, args.length ?? null, creds));
       } else if (name === 'get_unsubscribe_info') {
-        result = await withTimeout('get_unsubscribe_info', TIMEOUT.FETCH, () => getUnsubscribeInfo(args.uid, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_unsubscribe_info', TIMEOUT.FETCH, () => getUnsubscribeInfo(args.uid, args.mailbox || 'INBOX', creds));
       } else if (name === 'get_email_raw') {
-        result = await withTimeout('get_email_raw', TIMEOUT.FETCH, () => getEmailRaw(args.uid, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_email_raw', TIMEOUT.FETCH, () => getEmailRaw(args.uid, args.mailbox || 'INBOX', creds));
       } else if (name === 'get_thread') {
-        result = await withTimeout('get_thread', TIMEOUT.FETCH, () => getThread(args.uid, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_thread', TIMEOUT.FETCH, () => getThread(args.uid, args.mailbox || 'INBOX', creds));
       } else if (name === 'search_emails') {
-        const { query, mailbox, limit, queryMode, subjectQuery, bodyQuery, fromQuery, includeSnippet, ...filters } = args;
-        result = await withTimeout('search_emails', TIMEOUT.FETCH, () => searchEmails(query, mailbox || 'INBOX', limit || 10, filters, { queryMode, subjectQuery, bodyQuery, fromQuery, includeSnippet }));
+        const { query, mailbox, limit, queryMode, subjectQuery, bodyQuery, fromQuery, includeSnippet, account, ...filters } = args;
+        const creds = resolveCreds(account);
+        result = await withTimeout('search_emails', TIMEOUT.FETCH, () => searchEmails(query, mailbox || 'INBOX', limit || 10, filters, { queryMode, subjectQuery, bodyQuery, fromQuery, includeSnippet }, creds));
       } else if (name === 'get_emails_by_sender') {
-        result = await withTimeout('get_emails_by_sender', TIMEOUT.FETCH, () => getEmailsBySender(args.sender, args.mailbox || 'INBOX', args.limit || 10));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_emails_by_sender', TIMEOUT.FETCH, () => getEmailsBySender(args.sender, args.mailbox || 'INBOX', args.limit || 10, creds));
       } else if (name === 'get_emails_by_date_range') {
-        result = await withTimeout('get_emails_by_date_range', TIMEOUT.FETCH, () => getEmailsByDateRange(args.startDate, args.endDate, args.mailbox || 'INBOX', args.limit || 10));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_emails_by_date_range', TIMEOUT.FETCH, () => getEmailsByDateRange(args.startDate, args.endDate, args.mailbox || 'INBOX', args.limit || 10, creds));
       // ── Scan tier (60s) ──
       } else if (name === 'get_top_senders') {
-        result = await withTimeout('get_top_senders', TIMEOUT.SCAN, () => getTopSenders(args.mailbox || 'INBOX', args.sampleSize || 500, args.maxResults || 20));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_top_senders', TIMEOUT.SCAN, () => getTopSenders(args.mailbox || 'INBOX', args.sampleSize || 500, args.maxResults || 20, creds));
       } else if (name === 'get_unread_senders') {
-        result = await withTimeout('get_unread_senders', TIMEOUT.SCAN, () => getUnreadSenders(args.mailbox || 'INBOX', args.sampleSize || 500, args.maxResults || 20));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_unread_senders', TIMEOUT.SCAN, () => getUnreadSenders(args.mailbox || 'INBOX', args.sampleSize || 500, args.maxResults || 20, creds));
       } else if (name === 'get_storage_report') {
-        result = await withTimeout('get_storage_report', TIMEOUT.SCAN, () => getStorageReport(args.mailbox || 'INBOX', args.sampleSize || 100));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('get_storage_report', TIMEOUT.SCAN, () => getStorageReport(args.mailbox || 'INBOX', args.sampleSize || 100, creds));
       // ── Bulk operation tier (60s) ──
       } else if (name === 'bulk_delete_by_sender') {
-        result = await withTimeout('bulk_delete_by_sender', TIMEOUT.BULK_OP, () => bulkDeleteBySender(args.sender, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('bulk_delete_by_sender', TIMEOUT.BULK_OP, () => bulkDeleteBySender(args.sender, args.mailbox || 'INBOX', creds));
       } else if (name === 'bulk_delete_by_subject') {
-        result = await withTimeout('bulk_delete_by_subject', TIMEOUT.BULK_OP, () => bulkDeleteBySubject(args.subject, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('bulk_delete_by_subject', TIMEOUT.BULK_OP, () => bulkDeleteBySubject(args.subject, args.mailbox || 'INBOX', creds));
       } else if (name === 'bulk_mark_read') {
-        result = await withTimeout('bulk_mark_read', TIMEOUT.BULK_OP, () => bulkMarkRead(args.mailbox || 'INBOX', args.sender || null));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('bulk_mark_read', TIMEOUT.BULK_OP, () => bulkMarkRead(args.mailbox || 'INBOX', args.sender || null, creds));
       } else if (name === 'bulk_mark_unread') {
-        result = await withTimeout('bulk_mark_unread', TIMEOUT.BULK_OP, () => bulkMarkUnread(args.mailbox || 'INBOX', args.sender || null));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('bulk_mark_unread', TIMEOUT.BULK_OP, () => bulkMarkUnread(args.mailbox || 'INBOX', args.sender || null, creds));
       } else if (name === 'bulk_flag') {
-        const { flagged, mailbox, ...filters } = args;
-        result = await withTimeout('bulk_flag', TIMEOUT.BULK_OP, () => bulkFlag(filters, flagged, mailbox || 'INBOX'));
+        const { flagged, mailbox, account, ...filters } = args;
+        const creds = resolveCreds(account);
+        result = await withTimeout('bulk_flag', TIMEOUT.BULK_OP, () => bulkFlag(filters, flagged, mailbox || 'INBOX', creds));
       } else if (name === 'mark_older_than_read') {
-        result = await withTimeout('mark_older_than_read', TIMEOUT.BULK_OP, () => markOlderThanRead(args.days, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('mark_older_than_read', TIMEOUT.BULK_OP, () => markOlderThanRead(args.days, args.mailbox || 'INBOX', creds));
       } else if (name === 'bulk_flag_by_sender') {
-        result = await withTimeout('bulk_flag_by_sender', TIMEOUT.BULK_OP, () => bulkFlagBySender(args.sender, args.flagged, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('bulk_flag_by_sender', TIMEOUT.BULK_OP, () => bulkFlagBySender(args.sender, args.flagged, args.mailbox || 'INBOX', creds));
       } else if (name === 'delete_older_than') {
-        result = await withTimeout('delete_older_than', TIMEOUT.BULK_OP, () => deleteOlderThan(args.days, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('delete_older_than', TIMEOUT.BULK_OP, () => deleteOlderThan(args.days, args.mailbox || 'INBOX', creds));
       } else if (name === 'empty_trash') {
-        result = await withTimeout('empty_trash', TIMEOUT.BULK_OP, () => emptyTrash(args.dryRun || false));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('empty_trash', TIMEOUT.BULK_OP, () => emptyTrash(args.dryRun || false, creds));
       // ── No top-level timeout — chunked with internal timeouts ──
       } else if (name === 'bulk_move') {
-        const { targetMailbox, sourceMailbox, dryRun, limit, ...filters } = args;
-        result = await bulkMove(filters, targetMailbox, sourceMailbox || 'INBOX', dryRun || false, limit ?? null);
+        const { targetMailbox, sourceMailbox, dryRun, limit, account, ...filters } = args;
+        const creds = resolveCreds(account);
+        result = await bulkMove(filters, resolveMailbox(targetMailbox, creds), sourceMailbox || 'INBOX', dryRun || false, limit ?? null, creds);
       } else if (name === 'bulk_move_by_sender') {
-        result = await bulkMoveBySender(args.sender, args.targetMailbox, args.sourceMailbox || 'INBOX', args.dryRun || false);
+        const creds = resolveCreds(args.account);
+        result = await bulkMoveBySender(args.sender, resolveMailbox(args.targetMailbox, creds), args.sourceMailbox || 'INBOX', args.dryRun || false, creds);
       } else if (name === 'bulk_move_by_domain') {
-        result = await bulkMoveByDomain(args.domain, args.targetMailbox, args.sourceMailbox || 'INBOX', args.dryRun || false);
+        const creds = resolveCreds(args.account);
+        result = await bulkMoveByDomain(args.domain, resolveMailbox(args.targetMailbox, creds), args.sourceMailbox || 'INBOX', args.dryRun || false, creds);
       } else if (name === 'archive_older_than') {
-        result = await archiveOlderThan(args.days, args.targetMailbox, args.sourceMailbox || 'INBOX', args.dryRun || false);
+        const creds = resolveCreds(args.account);
+        result = await archiveOlderThan(args.days, resolveMailbox(args.targetMailbox, creds), args.sourceMailbox || 'INBOX', args.dryRun || false, creds);
       } else if (name === 'bulk_delete') {
-        // IMPROVEMENT 3: bulk_delete now has per-chunk timeouts internally
-        const { sourceMailbox, dryRun, ...filters } = args;
-        result = await bulkDelete(filters, sourceMailbox || 'INBOX', dryRun || false);
+        const { sourceMailbox, dryRun, account, ...filters } = args;
+        const creds = resolveCreds(account);
+        result = await bulkDelete(filters, sourceMailbox || 'INBOX', dryRun || false, creds);
       // ── Single-email tier (15s) ──
       } else if (name === 'flag_email') {
-        result = await withTimeout('flag_email', TIMEOUT.SINGLE, () => flagEmail(args.uid, args.flagged, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('flag_email', TIMEOUT.SINGLE, () => flagEmail(args.uid, args.flagged, args.mailbox || 'INBOX', creds));
       } else if (name === 'mark_as_read') {
-        result = await withTimeout('mark_as_read', TIMEOUT.SINGLE, () => markAsRead(args.uid, args.seen, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('mark_as_read', TIMEOUT.SINGLE, () => markAsRead(args.uid, args.seen, args.mailbox || 'INBOX', creds));
       } else if (name === 'delete_email') {
-        result = await withTimeout('delete_email', TIMEOUT.SINGLE, () => deleteEmail(args.uid, args.mailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('delete_email', TIMEOUT.SINGLE, () => deleteEmail(args.uid, args.mailbox || 'INBOX', creds));
       } else if (name === 'move_email') {
-        result = await withTimeout('move_email', TIMEOUT.SINGLE, () => moveEmail(args.uid, args.targetMailbox, args.sourceMailbox || 'INBOX'));
+        const creds = resolveCreds(args.account);
+        result = await withTimeout('move_email', TIMEOUT.SINGLE, () => moveEmail(args.uid, resolveMailbox(args.targetMailbox, creds), args.sourceMailbox || 'INBOX', creds));
       // ── Move status (synchronous, no timeout needed) ──
       } else if (name === 'get_move_status') {
         result = getMoveStatus();
@@ -986,6 +1101,16 @@ async function main() {
         result = logRead();
       } else if (name === 'log_clear') {
         result = logClear();
+      // ── Digest state (synchronous, no timeout needed) ──
+      } else if (name === 'get_digest_state') {
+        result = getDigestState();
+      } else if (name === 'update_digest_state') {
+        result = updateDigestState({
+          lastRun: args.lastRun,
+          processedUids: args.processedUids,
+          pendingActions: args.pendingActions,
+          skipCounts: args.skipCounts
+        });
       // ── Saved rules (synchronous CRUD; run_rule/run_all_rules use internal chunk timeouts) ──
       } else if (name === 'create_rule') {
         result = createRule(args.name, args.filters || {}, args.action, args.description || '');
@@ -999,26 +1124,30 @@ async function main() {
         result = await runAllRules(args.dryRun || false);
       // ── SMTP (email sending — uses SCAN tier 60s for two-phase fetch+send) ──
       } else if (name === 'compose_email') {
+        const creds = resolveCreds(args.account);
         result = await withTimeout('compose_email', TIMEOUT.SCAN, () =>
-          composeEmail(args.to, args.subject, args.body, { html: args.html, cc: args.cc, bcc: args.bcc, replyTo: args.replyTo })
+          composeEmail(args.to, args.subject, args.body, { html: args.html, cc: args.cc, bcc: args.bcc, replyTo: args.replyTo }, creds)
         );
       } else if (name === 'reply_to_email') {
+        const creds = resolveCreds(args.account);
         const origEmail = await withTimeout('get_email_for_reply', TIMEOUT.FETCH, () =>
-          getEmailContent(args.uid, args.mailbox || 'INBOX', 5000, true)
+          getEmailContent(args.uid, args.mailbox || 'INBOX', 5000, true, creds)
         );
         result = await withTimeout('reply_to_email', TIMEOUT.FETCH, () =>
-          replyToEmail(origEmail, args.body, { html: args.html, replyAll: args.replyAll || false, cc: args.cc })
+          replyToEmail(origEmail, args.body, { html: args.html, replyAll: args.replyAll || false, cc: args.cc }, creds)
         );
       } else if (name === 'forward_email') {
+        const creds = resolveCreds(args.account);
         const origEmail = await withTimeout('get_email_for_forward', TIMEOUT.FETCH, () =>
-          getEmailContent(args.uid, args.mailbox || 'INBOX', 5000, false)
+          getEmailContent(args.uid, args.mailbox || 'INBOX', 5000, false, creds)
         );
         result = await withTimeout('forward_email', TIMEOUT.FETCH, () =>
-          forwardEmail(origEmail, args.to, args.note || '', { html: args.html, cc: args.cc })
+          forwardEmail(origEmail, args.to, args.note || '', { html: args.html, cc: args.cc }, creds)
         );
       } else if (name === 'save_draft') {
+        const creds = resolveCreds(args.account);
         result = await withTimeout('save_draft', TIMEOUT.FETCH, () =>
-          saveDraft(args.to, args.subject, args.body, { html: args.html, cc: args.cc, bcc: args.bcc })
+          saveDraft(args.to, args.subject, args.body, { html: args.html, cc: args.cc, bcc: args.bcc }, creds)
         );
       // ── CardDAV / Contacts (FETCH tier 30s) ──
       } else if (name === 'list_contacts') {
@@ -1080,8 +1209,9 @@ async function main() {
         );
       // ── Smart extraction (SCAN tier 60s — LLM round-trip) ──
       } else if (name === 'suggest_event_from_email') {
+        const creds = resolveCreds(args.account);
         const email = await withTimeout('get_email_for_extraction', TIMEOUT.FETCH, () =>
-          getEmailContent(args.uid, args.mailbox || 'INBOX', 10000, false)
+          getEmailContent(args.uid, resolveMailbox(args.mailbox || 'INBOX', creds), 10000, false, creds)
         );
         result = formatEmailForExtraction(email);
       } else {

package/lib/digest.js

@@ -0,0 +1,46 @@
+// ─── Digest State ─────────────────────────────────────────────────────────────
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const DIGEST_FILE = join(homedir(), '.icloud-mcp-digest.json');
+
+const DEFAULT_STATE = {
+  lastRun: null,
+  processedUids: [],
+  pendingActions: [],
+  skipCounts: {}
+};
+
+function readDigest() {
+  if (!existsSync(DIGEST_FILE)) return { ...DEFAULT_STATE };
+  try { return JSON.parse(readFileSync(DIGEST_FILE, 'utf8')); }
+  catch { return { ...DEFAULT_STATE }; }
+}
+
+function writeDigest(data) {
+  writeFileSync(DIGEST_FILE, JSON.stringify(data, null, 2));
+}
+
+export function getDigestState() {
+  return readDigest();
+}
+
+export function updateDigestState({ processedUids, lastRun, pendingActions, skipCounts } = {}) {
+  const state = readDigest();
+  if (lastRun !== undefined) state.lastRun = lastRun;
+  if (processedUids !== undefined) {
+    // Merge with existing, deduplicate, cap at 5000 to prevent unbounded growth
+    const merged = [...new Set([...state.processedUids, ...processedUids])];
+    state.processedUids = merged.slice(-5000);
+  }
+  if (pendingActions !== undefined) state.pendingActions = pendingActions;
+  if (skipCounts !== undefined) {
+    // Accumulate skip counts per sender for smart unsubscribe
+    for (const [sender, count] of Object.entries(skipCounts)) {
+      state.skipCounts[sender] = (state.skipCounts[sender] || 0) + count;
+    }
+  }
+  writeDigest(state);
+  return state;
+}

package/lib/imap.js

@@ -7,23 +7,24 @@ import {
   findTextPart, findAttachments, estimateEmailSize, stripSubjectPrefixes
 } from './mime.js';
 
-const IMAP_USER = process.env.IMAP_USER;
-const IMAP_PASSWORD = process.env.IMAP_PASSWORD;
-
 const MANIFEST_FILE = join(homedir(), '.icloud-mcp-move-manifest.json');
 const RULES_FILE = join(homedir(), '.icloud-mcp-rules.json');
 const MAX_HISTORY = 5;
 
-// ─── IMPROVEMENT 1: Connection-level timeout on createClient ──────────────────
-// ImapFlow supports connectionTimeout and greetingTimeout options.
-// This ensures we don't hang forever waiting for iCloud to respond.
+// ─── Connection helpers ───────────────────────────────────────────────────────
+// creds = { user, pass, host } — if omitted, falls back to IMAP_USER/IMAP_PASSWORD env vars
+// and imap.mail.me.com. All exported functions accept an optional creds param
+// as their last argument so callers can target any IMAP account.
 
-function createClient() {
+function createClient(creds) {
+  const host = creds?.host || 'imap.mail.me.com';
+  const user = creds?.user || process.env.IMAP_USER;
+  const pass = creds?.pass || process.env.IMAP_PASSWORD;
   return new ImapFlow({
-    host: 'imap.mail.me.com',
+    host,
     port: 993,
     secure: true,
-    auth: { user: IMAP_USER, pass: IMAP_PASSWORD },
+    auth: { user, pass },
     logger: false,
     connectionTimeout: 15_000,   // 15s to establish TCP+TLS connection
     greetingTimeout: 15_000,     // 15s to receive IMAP greeting after connect
@@ -44,8 +45,8 @@ let _lastConnectTime = 0;
 let _connectGate = Promise.resolve();
 const MIN_CONNECT_INTERVAL = 10; // ms between connection initiations
 
-export function createRateLimitedClient() {
-  const client = createClient();
+export function createRateLimitedClient(creds) {
+  const client = createClient(creds);
   const originalConnect = client.connect.bind(client);
   client.connect = async () => {
     await new Promise(resolve => {
@@ -60,8 +61,8 @@ export function createRateLimitedClient() {
   return client;
 }
 
-async function openClient(mailbox) {
-  const client = createRateLimitedClient();
+async function openClient(mailbox, creds) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   if (mailbox) await client.mailboxOpen(mailbox);
   return client;
@@ -71,9 +72,9 @@ async function safeClose(client) {
   try { await client.logout(); } catch { try { client.close(); } catch { /* already gone */ } }
 }
 
-async function reconnect(client, mailbox) {
+async function reconnect(client, mailbox, creds) {
   safeClose(client);
-  return openClient(mailbox);
+  return openClient(mailbox, creds);
 }
 
 // ─── Move Manifest ────────────────────────────────────────────────────────────
@@ -476,7 +477,7 @@ async function verifyInTarget(targetClient, fingerprints, chunkIndex, knownTotal
 
 // Phase 1: Copy all chunks to target without deleting.
 // Returns { success, totalCopied, srcClient, errorResult }
-async function copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox) {
+async function copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox, creds) {
   let totalCopied = 0;
 
   for (const chunk of operation.chunks) {
@@ -496,7 +497,7 @@ async function copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox)
         } catch (err) {
           if (!isTransient(err)) throw err;
           moveLog(chunk.index, `fetch envelopes failed (${err.message}), reconnecting...`);
-          srcClient = await reconnect(srcClient, sourceMailbox);
+          srcClient = await reconnect(srcClient, sourceMailbox, creds);
           for await (const msg of srcClient.fetch(chunkUids, { envelope: true }, { uid: true })) {
             envelopes.push(msg);
           }
@@ -521,7 +522,7 @@ async function copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox)
         } catch (err) {
           if (!isTransient(err)) throw err;
           moveLog(chunk.index, `copy failed (${err.message}), reconnecting...`);
-          srcClient = await reconnect(srcClient, sourceMailbox);
+          srcClient = await reconnect(srcClient, sourceMailbox, creds);
           await srcClient.messageCopy(chunkUids, targetMailbox, { uid: true });
         }
         moveLog(chunk.index, `copied ${chunkUids.length} emails to target (${elapsed(t)})`);
@@ -557,7 +558,7 @@ async function copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox)
 
 // Phase 2: Verify all copied emails are present in target.
 // Returns { verification, tgtClient }
-async function verifyAllChunks(tgtClient, operation, targetMailbox) {
+async function verifyAllChunks(tgtClient, operation, targetMailbox, creds) {
   const allFingerprints = operation.chunks.flatMap(c => c.fingerprints);
 
   updateManifest((data) => {
@@ -571,7 +572,7 @@ async function verifyAllChunks(tgtClient, operation, targetMailbox) {
   } catch (err) {
     if (!isTransient(err)) throw err;
     moveLog('global', `mailboxOpen failed (${err.message}), reconnecting...`);
-    tgtClient = await reconnect(tgtClient, targetMailbox);
+    tgtClient = await reconnect(tgtClient, targetMailbox, creds);
     tgtMb = await tgtClient.mailboxOpen(targetMailbox);
   }
 
@@ -581,7 +582,7 @@ async function verifyAllChunks(tgtClient, operation, targetMailbox) {
   } catch (err) {
     if (!isTransient(err)) throw err;
     moveLog('global', `verify failed (${err.message}), reconnecting...`);
-    tgtClient = await reconnect(tgtClient, targetMailbox);
+    tgtClient = await reconnect(tgtClient, targetMailbox, creds);
     verification = await verifyInTarget(tgtClient, allFingerprints, 'global');
   }
 
@@ -590,7 +591,7 @@ async function verifyAllChunks(tgtClient, operation, targetMailbox) {
 
 // Phase 3: Delete all source emails in a single EXPUNGE.
 // Returns { srcClient }
-async function deleteAllChunks(srcClient, operation, sourceMailbox) {
+async function deleteAllChunks(srcClient, operation, sourceMailbox, creds) {
   const allUids = operation.chunks.flatMap(c => c.uids);
   const t = Date.now();
 
@@ -599,7 +600,7 @@ async function deleteAllChunks(srcClient, operation, sourceMailbox) {
   } catch (err) {
     if (!isTransient(err)) throw err;
     moveLog('global', `delete failed (${err.message}), reconnecting...`);
-    srcClient = await reconnect(srcClient, sourceMailbox);
+    srcClient = await reconnect(srcClient, sourceMailbox, creds);
     // Retry is idempotent — expunging already-gone UIDs is a no-op
     await srcClient.messageDelete(allUids, { uid: true });
   }
@@ -610,19 +611,19 @@ async function deleteAllChunks(srcClient, operation, sourceMailbox) {
 
 // ─── Safe Move (Option B: COPY-all → VERIFY-all → single EXPUNGE) ─────────────
 
-async function safeMoveEmails(uids, sourceMailbox, targetMailbox) {
+async function safeMoveEmails(uids, sourceMailbox, targetMailbox, creds) {
   const operation = startOperation(sourceMailbox, targetMailbox, uids);
   const opStart = Date.now();
 
   process.stderr.write(`[move] starting: ${uids.length} emails, ${operation.chunks.length} chunks, ${sourceMailbox} → ${targetMailbox}\n`);
 
-  let srcClient = await openClient(sourceMailbox);
-  let tgtClient = await openClient(targetMailbox);
+  let srcClient = await openClient(sourceMailbox, creds);
+  let tgtClient = await openClient(targetMailbox, creds);
 
   try {
     // Phase 1: COPY all chunks to target (no delete yet)
     process.stderr.write(`[move] phase 1/3: copying ${uids.length} emails in ${operation.chunks.length} chunks\n`);
-    const copyResult = await copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox);
+    const copyResult = await copyAllChunks(operation, srcClient, targetMailbox, sourceMailbox, creds);
     srcClient = copyResult.srcClient;
 
     if (!copyResult.success) {
@@ -637,7 +638,7 @@ async function safeMoveEmails(uids, sourceMailbox, targetMailbox) {
     let verifyResult;
     try {
       verifyResult = await withTimeout('verify all', TIMEOUT.VERIFY_ALL, () =>
-        verifyAllChunks(tgtClient, operation, targetMailbox)
+        verifyAllChunks(tgtClient, operation, targetMailbox, creds)
       );
       tgtClient = verifyResult.tgtClient;
     } catch (err) {
@@ -677,7 +678,7 @@ async function safeMoveEmails(uids, sourceMailbox, targetMailbox) {
     let deleteResult;
     try {
       deleteResult = await withTimeout('delete all', TIMEOUT.DELETE_ALL, () =>
-        deleteAllChunks(srcClient, operation, sourceMailbox)
+        deleteAllChunks(srcClient, operation, sourceMailbox, creds)
       );
       srcClient = deleteResult.srcClient;
     } catch (err) {
@@ -709,8 +710,8 @@ async function safeMoveEmails(uids, sourceMailbox, targetMailbox) {
 
 // ─── Email Functions ──────────────────────────────────────────────────────────
 
-export async function fetchEmails(mailbox = 'INBOX', limit = 10, onlyUnread = false, page = 1) {
-  const client = createRateLimitedClient();
+export async function fetchEmails(mailbox = 'INBOX', limit = 10, onlyUnread = false, page = 1, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   const mb = await client.mailboxOpen(mailbox);
   const total = mb.exists;
@@ -763,16 +764,16 @@ export async function fetchEmails(mailbox = 'INBOX', limit = 10, onlyUnread = fa
   return { emails, page, limit, total, totalPages: Math.ceil(total / limit), hasMore: (page * limit) < total };
 }
 
-export async function getInboxSummary(mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function getInboxSummary(mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   const status = await client.status(mailbox, { messages: true, unseen: true, recent: true });
   await client.logout();
   return { mailbox, total: status.messages, unread: status.unseen, recent: status.recent };
 }
 
-export async function getTopSenders(mailbox = 'INBOX', sampleSize = 500, maxResults = 20) {
-  const client = createRateLimitedClient();
+export async function getTopSenders(mailbox = 'INBOX', sampleSize = 500, maxResults = 20, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   const mb = await client.mailboxOpen(mailbox);
   const total = mb.exists;
@@ -800,8 +801,8 @@ export async function getTopSenders(mailbox = 'INBOX', sampleSize = 500, maxResu
   return { sampledEmails: count, topAddresses, topDomains };
 }
 
-export async function getUnreadSenders(mailbox = 'INBOX', sampleSize = 500, maxResults = 20) {
-  const client = createRateLimitedClient();
+export async function getUnreadSenders(mailbox = 'INBOX', sampleSize = 500, maxResults = 20, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const uids = (await client.search({ seen: false }, { uid: true })) ?? [];
@@ -822,8 +823,8 @@ export async function getUnreadSenders(mailbox = 'INBOX', sampleSize = 500, maxR
   return Object.entries(senderCounts).sort((a, b) => b[1] - a[1]).slice(0, maxResults).map(([address, count]) => ({ address, count }));
 }
 
-export async function getEmailsBySender(sender, mailbox = 'INBOX', limit = 10) {
-  const client = createRateLimitedClient();
+export async function getEmailsBySender(sender, mailbox = 'INBOX', limit = 10, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const uids = (await client.search({ from: sender }, { uid: true })) ?? [];
@@ -847,8 +848,8 @@ export async function getEmailsBySender(sender, mailbox = 'INBOX', limit = 10) {
   return { total, showing: emails.length, emails };
 }
 
-export async function bulkDeleteBySender(sender, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function bulkDeleteBySender(sender, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const uids = (await client.search({ from: sender }, { uid: true })) ?? [];
@@ -863,8 +864,8 @@ export async function bulkDeleteBySender(sender, mailbox = 'INBOX') {
   return { deleted, sender };
 }
 
-export async function markOlderThanRead(days, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function markOlderThanRead(days, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const date = new Date();
@@ -877,26 +878,26 @@ export async function markOlderThanRead(days, mailbox = 'INBOX') {
   return { marked: uids.length, olderThan: date.toISOString() };
 }
 
-export async function bulkMoveByDomain(domain, targetMailbox, sourceMailbox = 'INBOX', dryRun = false) {
-  const result = await bulkMove({ domain }, targetMailbox, sourceMailbox, dryRun);
+export async function bulkMoveByDomain(domain, targetMailbox, sourceMailbox = 'INBOX', dryRun = false, creds = null) {
+  const result = await bulkMove({ domain }, targetMailbox, sourceMailbox, dryRun, null, creds);
   return { ...result, domain };
 }
 
-export async function bulkMoveBySender(sender, targetMailbox, sourceMailbox = 'INBOX', dryRun = false) {
-  const client = createRateLimitedClient();
+export async function bulkMoveBySender(sender, targetMailbox, sourceMailbox = 'INBOX', dryRun = false, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(sourceMailbox);
   const uids = (await client.search({ from: sender }, { uid: true })) ?? [];
   await client.logout();
   if (dryRun) return { dryRun: true, wouldMove: uids.length, sender, sourceMailbox, targetMailbox };
   if (uids.length === 0) return { moved: 0 };
-  await ensureMailbox(targetMailbox);
-  const result = await safeMoveEmails(uids, sourceMailbox, targetMailbox);
+  await ensureMailbox(targetMailbox, creds);
+  const result = await safeMoveEmails(uids, sourceMailbox, targetMailbox, creds);
   return { ...result, sender, targetMailbox };
 }
 
-export async function bulkDeleteBySubject(subject, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function bulkDeleteBySubject(subject, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const uids = (await client.search({ subject }, { uid: true })) ?? [];
@@ -911,8 +912,8 @@ export async function bulkDeleteBySubject(subject, mailbox = 'INBOX') {
   return { deleted, subject };
 }
 
-export async function deleteOlderThan(days, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function deleteOlderThan(days, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const date = new Date();
@@ -929,8 +930,8 @@ export async function deleteOlderThan(days, mailbox = 'INBOX') {
   return { deleted, olderThan: date.toISOString() };
 }
 
-export async function getEmailsByDateRange(startDate, endDate, mailbox = 'INBOX', limit = 10) {
-  const client = createRateLimitedClient();
+export async function getEmailsByDateRange(startDate, endDate, mailbox = 'INBOX', limit = 10, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const uids = (await client.search({ since: new Date(startDate), before: new Date(endDate) }, { uid: true })) ?? [];
@@ -954,8 +955,8 @@ export async function getEmailsByDateRange(startDate, endDate, mailbox = 'INBOX'
   return { total, showing: emails.length, emails };
 }
 
-export async function bulkMarkRead(mailbox = 'INBOX', sender = null) {
-  const client = createRateLimitedClient();
+export async function bulkMarkRead(mailbox = 'INBOX', sender = null, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const query = sender ? { from: sender, seen: false } : { seen: false };
@@ -966,8 +967,8 @@ export async function bulkMarkRead(mailbox = 'INBOX', sender = null) {
   return { marked: uids.length, sender: sender || 'all' };
 }
 
-export async function bulkMarkUnread(mailbox = 'INBOX', sender = null) {
-  const client = createRateLimitedClient();
+export async function bulkMarkUnread(mailbox = 'INBOX', sender = null, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const query = sender ? { from: sender, seen: true } : { seen: true };
@@ -978,8 +979,8 @@ export async function bulkMarkUnread(mailbox = 'INBOX', sender = null) {
   return { marked: uids.length, sender: sender || 'all' };
 }
 
-export async function bulkFlag(filters, flagged, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function bulkFlag(filters, flagged, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const query = buildQuery(filters);
@@ -994,8 +995,8 @@ export async function bulkFlag(filters, flagged, mailbox = 'INBOX') {
   return { [flagged ? 'flagged' : 'unflagged']: uids.length, filters };
 }
 
-export async function bulkFlagBySender(sender, flagged, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function bulkFlagBySender(sender, flagged, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const raw = await client.search({ from: sender }, { uid: true });
@@ -1010,10 +1011,11 @@ export async function bulkFlagBySender(sender, flagged, mailbox = 'INBOX') {
   return { [flagged ? 'flagged' : 'unflagged']: uids.length, sender };
 }
 
-export async function emptyTrash(dryRun = false) {
+export async function emptyTrash(dryRun = false, creds = null) {
   const t0 = Date.now();
-  const trashFolders = ['Deleted Messages', 'Trash'];
-  const client = createRateLimitedClient();
+  // iCloud uses 'Deleted Messages'; Gmail uses '[Gmail]/Trash'; standard IMAP uses 'Trash'
+  const trashFolders = ['Deleted Messages', '[Gmail]/Trash', 'Trash'];
+  const client = createRateLimitedClient(creds);
   await client.connect();
 
   let mailbox = null;
@@ -1058,8 +1060,8 @@ export async function emptyTrash(dryRun = false) {
   return { deleted, mailbox, timeTaken: ((Date.now() - t0) / 1000).toFixed(1) + 's' };
 }
 
-export async function archiveOlderThan(days, targetMailbox, sourceMailbox = 'INBOX', dryRun = false) {
-  const client = createRateLimitedClient();
+export async function archiveOlderThan(days, targetMailbox, sourceMailbox = 'INBOX', dryRun = false, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(sourceMailbox);
   const date = new Date();
@@ -1069,13 +1071,13 @@ export async function archiveOlderThan(days, targetMailbox, sourceMailbox = 'INB
   await client.logout();
   if (dryRun) return { dryRun: true, wouldMove: uids.length, olderThan: date.toISOString(), sourceMailbox, targetMailbox };
   if (uids.length === 0) return { moved: 0, olderThan: date.toISOString(), sourceMailbox, targetMailbox };
-  await ensureMailbox(targetMailbox);
-  const result = await safeMoveEmails(uids, sourceMailbox, targetMailbox);
+  await ensureMailbox(targetMailbox, creds);
+  const result = await safeMoveEmails(uids, sourceMailbox, targetMailbox, creds);
   return { ...result, olderThan: date.toISOString(), sourceMailbox, targetMailbox };
 }
 
-export async function getStorageReport(mailbox = 'INBOX', sampleSize = 100) {
-  const client = createRateLimitedClient();
+export async function getStorageReport(mailbox = 'INBOX', sampleSize = 100, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
 
@@ -1130,9 +1132,9 @@ export async function getStorageReport(mailbox = 'INBOX', sampleSize = 100) {
   };
 }
 
-export async function getThread(uid, mailbox = 'INBOX') {
+export async function getThread(uid, mailbox = 'INBOX', creds = null) {
   const THREAD_CANDIDATE_CAP = 100;
-  const client = createRateLimitedClient();
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
 
@@ -1225,16 +1227,16 @@ export async function getThread(uid, mailbox = 'INBOX') {
   };
 }
 
-export async function createMailbox(name) {
-  const client = createRateLimitedClient();
+export async function createMailbox(name, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxCreate(name);
   await client.logout();
   return { created: name };
 }
 
-export async function renameMailbox(oldName, newName) {
-  const client = createRateLimitedClient();
+export async function renameMailbox(oldName, newName, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   try {
     await Promise.race([
@@ -1249,8 +1251,8 @@ export async function renameMailbox(oldName, newName) {
   return { renamed: { from: oldName, to: newName } };
 }
 
-export async function deleteMailbox(name) {
-  const client = createRateLimitedClient();
+export async function deleteMailbox(name, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   try {
     await Promise.race([
@@ -1265,8 +1267,8 @@ export async function deleteMailbox(name) {
   return { deleted: name };
 }
 
-export async function getMailboxSummary(mailbox) {
-  const client = createRateLimitedClient();
+export async function getMailboxSummary(mailbox, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   const status = await client.status(mailbox, { messages: true, unseen: true, recent: true });
   await client.logout();
@@ -1275,8 +1277,8 @@ export async function getMailboxSummary(mailbox) {
 
 // ─── Email content fetcher (MIME-aware) ───────────────────────────────────────
 
-export async function getEmailContent(uid, mailbox = 'INBOX', maxChars = 8000, includeHeaders = false) {
-  const client = createRateLimitedClient();
+export async function getEmailContent(uid, mailbox = 'INBOX', maxChars = 8000, includeHeaders = false, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
 
@@ -1384,8 +1386,8 @@ export async function getEmailContent(uid, mailbox = 'INBOX', maxChars = 8000, i
   return result;
 }
 
-export async function listAttachments(uid, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function listAttachments(uid, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const meta = await client.fetchOne(uid, { envelope: true, bodyStructure: true }, { uid: true });
@@ -1400,8 +1402,8 @@ export async function listAttachments(uid, mailbox = 'INBOX') {
   };
 }
 
-export async function getUnsubscribeInfo(uid, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function getUnsubscribeInfo(uid, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const meta = await client.fetchOne(uid, { headers: new Set(['list-unsubscribe', 'list-unsubscribe-post']) }, { uid: true });
@@ -1414,9 +1416,9 @@ export async function getUnsubscribeInfo(uid, mailbox = 'INBOX') {
   return { uid, email, url, raw };
 }
 
-export async function getEmailRaw(uid, mailbox = 'INBOX') {
+export async function getEmailRaw(uid, mailbox = 'INBOX', creds = null) {
   const MAX_RAW_BYTES = 1 * 1024 * 1024; // 1 MB cap
-  const client = createRateLimitedClient();
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const msg = await client.fetchOne(uid, { source: true }, { uid: true });
@@ -1434,8 +1436,8 @@ export async function getEmailRaw(uid, mailbox = 'INBOX') {
   };
 }
 
-export async function getAttachment(uid, partId, mailbox = 'INBOX', offset = null, length = null) {
-  const client = createRateLimitedClient();
+export async function getAttachment(uid, partId, mailbox = 'INBOX', offset = null, length = null, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
 
@@ -1527,8 +1529,8 @@ export async function getAttachment(uid, partId, mailbox = 'INBOX', offset = nul
   };
 }
 
-export async function flagEmail(uid, flagged, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function flagEmail(uid, flagged, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   if (flagged) {
@@ -1540,8 +1542,8 @@ export async function flagEmail(uid, flagged, mailbox = 'INBOX') {
   return true;
 }
 
-export async function markAsRead(uid, seen, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function markAsRead(uid, seen, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   if (seen) {
@@ -1553,8 +1555,8 @@ export async function markAsRead(uid, seen, mailbox = 'INBOX') {
   return true;
 }
 
-export async function deleteEmail(uid, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function deleteEmail(uid, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   await client.messageDelete(uid, { uid: true });
@@ -1562,8 +1564,8 @@ export async function deleteEmail(uid, mailbox = 'INBOX') {
   return true;
 }
 
-export async function listMailboxes() {
-  const client = createRateLimitedClient();
+export async function listMailboxes(creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   const tree = await client.listTree();
   const mailboxes = [];
@@ -1578,9 +1580,9 @@ export async function listMailboxes() {
   return mailboxes;
 }
 
-export async function searchEmails(query, mailbox = 'INBOX', limit = 10, filters = {}, options = {}) {
+export async function searchEmails(query, mailbox = 'INBOX', limit = 10, filters = {}, options = {}, creds = null) {
   const { queryMode = 'or', subjectQuery, bodyQuery, fromQuery, includeSnippet = false } = options;
-  const client = createRateLimitedClient();
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
 
@@ -1666,8 +1668,8 @@ export async function searchEmails(query, mailbox = 'INBOX', limit = 10, filters
   return { total: uids.length, showing: emails.length, emails };
 }
 
-export async function moveEmail(uid, targetMailbox, sourceMailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function moveEmail(uid, targetMailbox, sourceMailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(sourceMailbox);
   await client.messageMove(uid, targetMailbox, { uid: true });
@@ -1705,15 +1707,15 @@ async function filterUidsByAttachment(client, uids) {
   return result;
 }
 
-async function ensureMailbox(name) {
-  const client = createRateLimitedClient();
+async function ensureMailbox(name, creds) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   try { await client.mailboxCreate(name); } catch { /* already exists */ }
   await client.logout();
 }
 
-export async function bulkMove(filters, targetMailbox, sourceMailbox = 'INBOX', dryRun = false, limit = null) {
-  const client = createRateLimitedClient();
+export async function bulkMove(filters, targetMailbox, sourceMailbox = 'INBOX', dryRun = false, limit = null, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(sourceMailbox);
   const query = buildQuery(filters);
@@ -1734,8 +1736,8 @@ export async function bulkMove(filters, targetMailbox, sourceMailbox = 'INBOX',
   }
   if (uids.length === 0) return { moved: 0, sourceMailbox, targetMailbox };
 
-  await ensureMailbox(targetMailbox);
-  const result = await safeMoveEmails(uids, sourceMailbox, targetMailbox);
+  await ensureMailbox(targetMailbox, creds);
+  const result = await safeMoveEmails(uids, sourceMailbox, targetMailbox, creds);
   return { ...result, sourceMailbox, targetMailbox, filters };
 }
 
@@ -1744,8 +1746,8 @@ export async function bulkMove(filters, targetMailbox, sourceMailbox = 'INBOX',
 // timeout. If a single chunk hangs, we bail with a partial result instead of
 // hanging forever.
 
-export async function bulkDelete(filters, sourceMailbox = 'INBOX', dryRun = false) {
-  const client = createRateLimitedClient();
+export async function bulkDelete(filters, sourceMailbox = 'INBOX', dryRun = false, creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(sourceMailbox);
   const query = buildQuery(filters);
@@ -1788,8 +1790,8 @@ export async function bulkDelete(filters, sourceMailbox = 'INBOX', dryRun = fals
   return { deleted, sourceMailbox, filters };
 }
 
-export async function countEmails(filters, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+export async function countEmails(filters, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const query = buildQuery(filters);
@@ -1856,8 +1858,8 @@ export function deleteRule(name) {
   return { deleted: true, name };
 }
 
-async function bulkMarkByFilters(filters, read, mailbox = 'INBOX') {
-  const client = createRateLimitedClient();
+async function bulkMarkByFilters(filters, read, mailbox = 'INBOX', creds = null) {
+  const client = createRateLimitedClient(creds);
   await client.connect();
   await client.mailboxOpen(mailbox);
   const base = buildQuery(filters);

package/lib/smtp.js

@@ -1,20 +1,20 @@
 import nodemailer from 'nodemailer';
 import { ImapFlow } from 'imapflow';
 
-const SMTP_HOST = 'smtp.mail.me.com';
 const SMTP_PORT = 587;
 
-function getCredentials() {
-  const user = process.env.IMAP_USER;
-  const pass = process.env.IMAP_PASSWORD;
+// creds = { user, pass, host (IMAP), smtpHost } — falls back to env vars / iCloud defaults
+function getCredentials(creds) {
+  const user = creds?.user || process.env.IMAP_USER;
+  const pass = creds?.pass || process.env.IMAP_PASSWORD;
   if (!user || !pass) throw new Error('IMAP_USER and IMAP_PASSWORD are required for SMTP operations');
-  return { user, pass };
+  return { user, pass, imapHost: creds?.host || 'imap.mail.me.com', smtpHost: creds?.smtpHost || 'smtp.mail.me.com' };
 }
 
-function createTransport() {
-  const { user, pass } = getCredentials();
+function createTransport(creds) {
+  const { user, pass, smtpHost } = getCredentials(creds);
   return nodemailer.createTransport({
-    host: SMTP_HOST,
+    host: smtpHost,
     port: SMTP_PORT,
     secure: false, // STARTTLS on port 587
     auth: { user, pass },
@@ -63,9 +63,9 @@ function applyBody(mailOptions, body, html) {
 
 // ─── compose_email ────────────────────────────────────────────────────────────
 
-export async function composeEmail(to, subject, body, opts = {}) {
-  const { user } = getCredentials();
-  const transport = createTransport();
+export async function composeEmail(to, subject, body, opts = {}, creds = null) {
+  const { user } = getCredentials(creds);
+  const transport = createTransport(creds);
   const mailOptions = { from: user, to: normalizeAddresses(to), subject };
   applyBody(mailOptions, body, opts.html);
   if (opts.cc)      mailOptions.cc      = normalizeAddresses(opts.cc);
@@ -84,9 +84,9 @@ export async function composeEmail(to, subject, body, opts = {}) {
 // ─── reply_to_email ───────────────────────────────────────────────────────────
 // email = getEmailContent(uid, mailbox, maxChars, includeHeaders: true) result
 
-export async function replyToEmail(email, body, opts = {}) {
-  const { user } = getCredentials();
-  const transport = createTransport();
+export async function replyToEmail(email, body, opts = {}, creds = null) {
+  const { user } = getCredentials(creds);
+  const transport = createTransport(creds);
 
   const originalSubject   = email.subject ?? '';
   const originalMessageId = email.headers?.messageId ?? null;
@@ -138,9 +138,9 @@ export async function replyToEmail(email, body, opts = {}) {
 // ─── forward_email ────────────────────────────────────────────────────────────
 // email = getEmailContent result (no need for includeHeaders)
 
-export async function forwardEmail(email, to, note = '', opts = {}) {
-  const { user } = getCredentials();
-  const transport = createTransport();
+export async function forwardEmail(email, to, note = '', opts = {}, creds = null) {
+  const { user } = getCredentials(creds);
+  const transport = createTransport(creds);
 
   const originalSubject = email.subject ?? '';
   const subject = /^fwd:/i.test(originalSubject) ? originalSubject : `Fwd: ${originalSubject}`;
@@ -173,8 +173,8 @@ export async function forwardEmail(email, to, note = '', opts = {}) {
 // ─── save_draft ───────────────────────────────────────────────────────────────
 // Builds the raw MIME message without sending, then APPENDs to Drafts via IMAP.
 
-export async function saveDraft(to, subject, body, opts = {}) {
-  const { user, pass } = getCredentials();
+export async function saveDraft(to, subject, body, opts = {}, creds = null) {
+  const { user, pass, imapHost } = getCredentials(creds);
 
   const mailOptions = { from: user, to: normalizeAddresses(to), subject };
   applyBody(mailOptions, body, opts.html);
@@ -187,7 +187,7 @@ export async function saveDraft(to, subject, body, opts = {}) {
 
   // APPEND the raw message to the Drafts folder via IMAP
   const client = new ImapFlow({
-    host: 'imap.mail.me.com',
+    host: imapHost,
     port: 993,
     secure: true,
     auth: { user, pass },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icloud-mcp",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "A Model Context Protocol (MCP) server for iCloud Mail",
   "main": "index.js",
   "bin": {

package/run-digest.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// ─── Inbox Intelligence — Digest Status Helper ────────────────────────────────
+// Shows current digest state and what's pending. Not the runner itself —
+// Claude Code is the runner. Use this to inspect state or reset it.
+//
+// Usage:
+//   node run-digest.js            → show current state
+//   node run-digest.js --reset    → clear all processed UIDs and state
+
+import { getDigestState, updateDigestState } from './lib/digest.js';
+
+const args = process.argv.slice(2);
+
+if (args.includes('--reset')) {
+  updateDigestState({
+    lastRun: null,
+    processedUids: [],
+    pendingActions: [],
+    skipCounts: {}
+  });
+  // Force full reset by re-reading and overwriting
+  const { writeFileSync } = await import('fs');
+  const { homedir } = await import('os');
+  const { join } = await import('path');
+  writeFileSync(
+    join(homedir(), '.icloud-mcp-digest.json'),
+    JSON.stringify({ lastRun: null, processedUids: [], pendingActions: [], skipCounts: {} }, null, 2)
+  );
+  console.log('✓ Digest state reset.');
+  process.exit(0);
+}
+
+const state = getDigestState();
+
+console.log('\n── Digest State ──────────────────────────────────────────');
+console.log(`Last run:          ${state.lastRun ? new Date(state.lastRun).toLocaleString() : 'never'}`);
+console.log(`Processed UIDs:    ${state.processedUids.length}`);
+console.log(`Pending actions:   ${state.pendingActions.length}`);
+
+if (state.pendingActions.length > 0) {
+  for (const a of state.pendingActions) {
+    console.log(`  • [${a.type}] ${a.subject}${a.dueDate ? ' — due ' + a.dueDate : ''}`);
+  }
+}
+
+const candidates = Object.entries(state.skipCounts)
+  .filter(([, c]) => c >= 3)
+  .sort((a, b) => b[1] - a[1]);
+
+if (candidates.length > 0) {
+  console.log(`\nUnsubscribe candidates (skipped 3+ times):`);
+  for (const [sender, count] of candidates) {
+    console.log(`  • ${sender} (${count}×)`);
+  }
+}
+
+console.log('──────────────────────────────────────────────────────────\n');