icloud-mcp 2.0.0 → 2.2.0

package/lib/mime.js

@@ -0,0 +1,134 @@
+// ─── MIME parsing helpers ─────────────────────────────────────────────────────
+// Pure functions — no IMAP, no side effects.
+
+export function decodeTransferEncoding(buffer, encoding) {
+  const enc = (encoding || '7bit').toLowerCase().trim();
+  if (enc === 'base64') {
+    return Buffer.from(buffer.toString('ascii').replace(/\s/g, ''), 'base64');
+  }
+  if (enc === 'quoted-printable') {
+    const str = buffer.toString('binary')
+      .replace(/[\t ]+$/gm, '')
+      .replace(/=(?:\r?\n|$)/g, '');
+    const result = Buffer.alloc(str.length);
+    let pos = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === '=' && i + 2 < str.length) {
+        const hex = str.slice(i + 1, i + 3);
+        if (/^[\da-fA-F]{2}$/.test(hex)) {
+          result[pos++] = parseInt(hex, 16);
+          i += 2;
+          continue;
+        }
+      }
+      result[pos++] = str.charCodeAt(i) & 0xff;
+    }
+    return result.slice(0, pos);
+  }
+  return buffer;
+}
+
+export async function decodeCharset(buffer, charset) {
+  const cs = (charset || 'utf-8').toLowerCase().trim();
+  const nativeMap = { 'utf-8': 'utf8', 'utf8': 'utf8', 'us-ascii': 'ascii',
+    'ascii': 'ascii', 'latin1': 'latin1', 'iso-8859-1': 'latin1', 'binary': 'binary' };
+  if (nativeMap[cs]) return buffer.toString(nativeMap[cs]);
+  try {
+    const { default: iconv } = await import('iconv-lite');
+    if (iconv.encodingExists(cs)) return iconv.decode(buffer, cs);
+  } catch { /* iconv unavailable */ }
+  return buffer.toString('utf8');
+}
+
+export function stripHtml(html) {
+  return html
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, ' ')
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<\/div>/gi, '\n')
+    .replace(/<\/li>/gi, '\n')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/&quot;/gi, '"')
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n)))
+    .replace(/[ \t]+/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+// Extract a specific header from imapflow's headers property.
+// imapflow returns headers as a raw Buffer (BODY[HEADER.FIELDS ...] response bytes),
+// so we parse it as text with MIME unfolding. Falls back to .get() if it's a Map.
+export function extractRawHeader(headers, name) {
+  if (!headers) return '';
+  let str;
+  if (Buffer.isBuffer(headers)) {
+    str = headers.toString();
+  } else if (typeof headers.get === 'function') {
+    return (headers.get(name) ?? '').toString().trim();
+  } else {
+    str = headers.toString();
+  }
+  // Unfold MIME-folded header values (CRLF + whitespace = continuation)
+  const unfolded = str.replace(/\r?\n[ \t]+/g, ' ');
+  return unfolded.match(new RegExp(`^${name}:\\s*(.+)`, 'im'))?.[1]?.trim() ?? '';
+}
+
+export function findTextPart(node) {
+  if (!node.childNodes) {
+    if (node.type && node.type.startsWith('text/') && node.disposition !== 'attachment') {
+      return { partId: null, type: node.type, encoding: node.encoding, charset: node.parameters?.charset, size: node.size };
+    }
+    return null;
+  }
+  if (node.type === 'multipart/alternative') {
+    let plainPart = null, htmlPart = null;
+    for (const child of node.childNodes) {
+      if (child.childNodes || child.disposition === 'attachment') continue;
+      if (child.type === 'text/plain') plainPart = child;
+      else if (child.type === 'text/html') htmlPart = child;
+    }
+    const chosen = plainPart || htmlPart;
+    if (chosen) return { partId: chosen.part, type: chosen.type, encoding: chosen.encoding, charset: chosen.parameters?.charset, size: chosen.size };
+  }
+  for (const child of node.childNodes) {
+    if (child.disposition === 'attachment') continue;
+    const found = findTextPart(child);
+    if (found) return found;
+  }
+  return null;
+}
+
+export function findAttachments(node, parts = []) {
+  if (node.childNodes) {
+    for (const child of node.childNodes) findAttachments(child, parts);
+  } else {
+    const filename = node.dispositionParameters?.filename ?? node.parameters?.name ?? null;
+    const isTextBody = (node.type === 'text/plain' || node.type === 'text/html') && node.disposition !== 'attachment';
+    if (node.disposition === 'attachment' || node.disposition === 'inline' || (filename && !isTextBody)) {
+      parts.push({
+        partId: node.part ?? 'TEXT',
+        filename,
+        mimeType: node.type ?? 'application/octet-stream',
+        size: node.size ?? 0,
+        encoding: node.encoding ?? '7bit',
+        disposition: node.disposition ?? 'attachment'
+      });
+    }
+  }
+  return parts;
+}
+
+export function estimateEmailSize(node) {
+  if (node.childNodes) return node.childNodes.reduce((s, c) => s + estimateEmailSize(c), 0);
+  return node.size || 0;
+}
+
+export function stripSubjectPrefixes(subject) {
+  if (!subject) return '';
+  return subject.replace(/^(Re:|RE:|Fwd:|FWD:|Fw:|FW:|AW:|回复:|转发:)\s*/i, '').trim();
+}

package/lib/session.js

@@ -0,0 +1,28 @@
+// ─── Session Log ──────────────────────────────────────────────────────────────
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const LOG_FILE = join(homedir(), '.icloud-mcp-session.json');
+
+export function logRead() {
+  if (!existsSync(LOG_FILE)) return { steps: [], startedAt: null };
+  try {
+    return JSON.parse(readFileSync(LOG_FILE, 'utf8'));
+  } catch {
+    return { steps: [], startedAt: null };
+  }
+}
+
+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));
+  return log;
+}
+
+export function logClear() {
+  writeFileSync(LOG_FILE, JSON.stringify({ steps: [], startedAt: null }, null, 2));
+  return { cleared: true };
+}

package/lib/smtp.js

@@ -0,0 +1,220 @@
+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;
+  if (!user || !pass) throw new Error('IMAP_USER and IMAP_PASSWORD are required for SMTP operations');
+  return { user, pass };
+}
+
+function createTransport() {
+  const { user, pass } = getCredentials();
+  return nodemailer.createTransport({
+    host: SMTP_HOST,
+    port: SMTP_PORT,
+    secure: false, // STARTTLS on port 587
+    auth: { user, pass },
+    connectionTimeout: 15_000,
+    socketTimeout: 30_000,
+  });
+}
+
+function normalizeAddresses(val) {
+  if (!val) return undefined;
+  return Array.isArray(val) ? val.join(', ') : val;
+}
+
+// Convert HTML to a readable plain-text fallback for multipart/alternative
+function htmlToText(html) {
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<\/h[1-6]>/gi, '\n\n')
+    .replace(/<\/li>/gi, '\n')
+    .replace(/<\/tr>/gi, '\n')
+    .replace(/<\/t[dh]>/gi, '\t')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function applyBody(mailOptions, body, html) {
+  if (html && body) {
+    // Both provided: multipart/alternative, clients choose which to render
+    mailOptions.text = body;
+    mailOptions.html = html;
+  } else if (html) {
+    // HTML only: auto-generate plain text fallback
+    mailOptions.html = html;
+    mailOptions.text = htmlToText(html);
+  } else {
+    mailOptions.text = body;
+  }
+}
+
+// ─── compose_email ────────────────────────────────────────────────────────────
+
+export async function composeEmail(to, subject, body, opts = {}) {
+  const { user } = getCredentials();
+  const transport = createTransport();
+  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.replyTo) mailOptions.replyTo = opts.replyTo;
+
+  const info = await transport.sendMail(mailOptions);
+  return {
+    sent: true,
+    messageId: info.messageId,
+    accepted: info.accepted,
+    rejected: info.rejected,
+  };
+}
+
+// ─── reply_to_email ───────────────────────────────────────────────────────────
+// email = getEmailContent(uid, mailbox, maxChars, includeHeaders: true) result
+
+export async function replyToEmail(email, body, opts = {}) {
+  const { user } = getCredentials();
+  const transport = createTransport();
+
+  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}`;
+
+  // 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);
+  }
+
+  const mailOptions = {
+    from: user,
+    to: toAddresses.join(', '),
+    subject,
+    inReplyTo: originalMessageId,
+    references,
+  };
+  applyBody(mailOptions, body, opts.html);
+  if (opts.cc) mailOptions.cc = normalizeAddresses(opts.cc);
+
+  const info = await transport.sendMail(mailOptions);
+  return {
+    sent: true,
+    messageId: info.messageId,
+    accepted: info.accepted,
+    rejected: info.rejected,
+    inReplyTo: originalMessageId,
+  };
+}
+
+// ─── forward_email ────────────────────────────────────────────────────────────
+// email = getEmailContent result (no need for includeHeaders)
+
+export async function forwardEmail(email, to, note = '', opts = {}) {
+  const { user } = getCredentials();
+  const transport = createTransport();
+
+  const originalSubject = email.subject ?? '';
+  const subject = /^fwd:/i.test(originalSubject) ? originalSubject : `Fwd: ${originalSubject}`;
+
+  const forwardHeader = [
+    '---------- Forwarded message ----------',
+    `From: ${email.from ?? '(unknown)'}`,
+    `Date: ${email.date ? new Date(email.date).toUTCString() : '(unknown)'}`,
+    `Subject: ${originalSubject}`,
+    '',
+  ].join('\n');
+
+  const forwardBody = note
+    ? `${note}\n\n${forwardHeader}\n${email.body ?? ''}`
+    : `${forwardHeader}\n${email.body ?? ''}`;
+
+  const mailOptions = { from: user, to: normalizeAddresses(to), subject };
+  applyBody(mailOptions, forwardBody, opts.html);
+  if (opts.cc) mailOptions.cc = normalizeAddresses(opts.cc);
+
+  const info = await transport.sendMail(mailOptions);
+  return {
+    sent: true,
+    messageId: info.messageId,
+    accepted: info.accepted,
+    rejected: info.rejected,
+  };
+}
+
+// ─── 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();
+
+  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);
+
+  // 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({
+    host: 'imap.mail.me.com',
+    port: 993,
+    secure: true,
+    auth: { user, pass },
+    logger: false,
+    connectionTimeout: 15_000,
+    greetingTimeout: 15_000,
+    socketTimeout: 60_000,
+  });
+
+  await client.connect();
+
+  let draftMailbox = 'Drafts';
+  try {
+    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 mailboxes = await client.list();
+      const draftMb = mailboxes.find(mb => mb.flags?.has('\\Drafts'));
+      draftMailbox = draftMb?.path ?? 'Drafts';
+      await client.append(draftMailbox, rawMessage, ['\\Draft', '\\Seen']);
+    } else {
+      throw err;
+    }
+  } finally {
+    try { await client.logout(); } catch { client.close(); }
+  }
+
+  return { saved: true, mailbox: draftMailbox, to: mailOptions.to, subject };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icloud-mcp",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "A Model Context Protocol (MCP) server for iCloud Mail",
   "main": "index.js",
   "bin": {
@@ -22,6 +22,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "imapflow": "^1.2.10"
+    "imapflow": "^1.2.10",
+    "nodemailer": "^8.0.2"
   }
 }