mcp-icloud 2.1.1

package/contacts/local-client.js

@@ -0,0 +1,372 @@
+/**
+ * Local Contacts Client
+ * Accesses Contacts.app via AppleScript
+ */
+
+const { runAppleScript, runJXA, escapeAppleScript, escapeJXA, asInt } = require('../utils/applescript');
+const config = require('../config');
+
+/**
+ * List contacts
+ * @param {number} count - Number of contacts to retrieve
+ * @returns {Promise<Array>} - List of contacts
+ */
+async function listContacts(count = 25) {
+  const script = `
+    const contacts = Application('Contacts');
+    const people = contacts.people();
+    let result = [];
+
+    const limit = Math.min(${asInt(count, 25)}, people.length);
+    for (let i = 0; i < limit; i++) {
+      const person = people[i];
+      try {
+        const emails = person.emails();
+        const phones = person.phones();
+
+        let emailList = [];
+        for (let e of emails) { emailList.push(e.value()); }
+        let phoneList = [];
+        for (let p of phones) { phoneList.push(p.value()); }
+
+        result.push({
+          id: person.id(),
+          name: person.name() || '',
+          firstName: person.firstName() || '',
+          lastName: person.lastName() || '',
+          organization: person.organization() || '',
+          jobTitle: person.jobTitle() || '',
+          emails: emailList,
+          phones: phoneList,
+          email: emailList.length > 0 ? emailList[0] : '',
+          phone: phoneList.length > 0 ? phoneList[0] : ''
+        });
+      } catch (e) {}
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * Search contacts
+ * @param {string} query - Search query
+ * @param {number} count - Max results
+ * @returns {Promise<Array>} - Matching contacts
+ */
+async function searchContacts(query, count = 25) {
+  const searchTerm = escapeJXA(query.toLowerCase());
+
+  const script = `
+    const contacts = Application('Contacts');
+    const people = contacts.people();
+    let result = [];
+
+    for (let person of people) {
+      if (result.length >= ${asInt(count, 25)}) break;
+
+      try {
+        const name = (person.name() || '').toLowerCase();
+        const org = (person.organization() || '').toLowerCase();
+        const emails = person.emails();
+        const phones = person.phones();
+
+        let emailMatch = false;
+        for (let e of emails) {
+          if (e.value().toLowerCase().includes("${searchTerm}")) {
+            emailMatch = true;
+            break;
+          }
+        }
+
+        // Normalize: strip non-digits for phone comparison
+        const searchDigits = "${searchTerm}".replace(/[^0-9]/g, '');
+        let phoneMatch = false;
+        for (let p of phones) {
+          const phoneDigits = p.value().replace(/[^0-9]/g, '');
+          if (p.value().includes("${searchTerm}") || (searchDigits.length >= 6 && phoneDigits.includes(searchDigits))) {
+            phoneMatch = true;
+            break;
+          }
+        }
+
+        if (name.includes("${searchTerm}") || org.includes("${searchTerm}") || emailMatch || phoneMatch) {
+          let emailList = [];
+          for (let e of emails) { emailList.push(e.value()); }
+          let phoneList = [];
+          for (let p of phones) { phoneList.push(p.value()); }
+
+          result.push({
+            id: person.id(),
+            name: person.name() || '',
+            firstName: person.firstName() || '',
+            lastName: person.lastName() || '',
+            organization: person.organization() || '',
+            jobTitle: person.jobTitle() || '',
+            emails: emailList,
+            phones: phoneList,
+            email: emailList.length > 0 ? emailList[0] : '',
+            phone: phoneList.length > 0 ? phoneList[0] : ''
+          });
+        }
+      } catch (e) {}
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * Read a specific contact
+ * @param {string} contactId - Contact ID
+ * @returns {Promise<Object>} - Contact details
+ */
+async function readContact(contactId) {
+  const script = `
+    const contacts = Application('Contacts');
+    const person = contacts.people.byId("${escapeJXA(contactId)}");
+
+    const emails = person.emails();
+    const phones = person.phones();
+    const addresses = person.addresses();
+
+    let emailList = [];
+    for (let e of emails) {
+      emailList.push({ label: e.label() || 'email', value: e.value() });
+    }
+
+    let phoneList = [];
+    for (let p of phones) {
+      phoneList.push({ label: p.label() || 'phone', value: p.value() });
+    }
+
+    let addressList = [];
+    for (let a of addresses) {
+      addressList.push({
+        label: a.label() || 'address',
+        street: a.street() || '',
+        city: a.city() || '',
+        state: a.state() || '',
+        zip: a.zip() || '',
+        country: a.country() || ''
+      });
+    }
+
+    JSON.stringify({
+      id: person.id(),
+      name: person.name() || '',
+      firstName: person.firstName() || '',
+      lastName: person.lastName() || '',
+      organization: person.organization() || '',
+      jobTitle: person.jobTitle() || '',
+      department: person.department() || '',
+      note: person.note() || '',
+      birthday: person.birthDate() ? person.birthDate().toISOString() : null,
+      emails: emailList,
+      phones: phoneList,
+      addresses: addressList
+    });
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : null;
+}
+
+/**
+ * Create a new contact
+ * @param {Object} options - Contact options
+ * @returns {Promise<Object>} - Created contact info
+ */
+async function createContact({ displayName, firstName, lastName, organization, jobTitle, email, phone, note }) {
+  let properties = [];
+
+  if (firstName) properties.push(`first name:"${escapeAppleScript(firstName)}"`);
+  if (lastName) properties.push(`last name:"${escapeAppleScript(lastName)}"`);
+  if (organization) properties.push(`organization:"${escapeAppleScript(organization)}"`);
+  if (jobTitle) properties.push(`job title:"${escapeAppleScript(jobTitle)}"`);
+  if (note) properties.push(`note:"${escapeAppleScript(note)}"`);
+
+  let script = `
+    tell application "Contacts"
+      set newPerson to make new person with properties {${properties.join(', ')}}
+  `;
+
+  if (email) {
+    script += `
+      tell newPerson
+        make new email at end of emails with properties {label:"work", value:"${escapeAppleScript(email)}"}
+      end tell
+    `;
+  }
+
+  if (phone) {
+    script += `
+      tell newPerson
+        make new phone at end of phones with properties {label:"mobile", value:"${escapeAppleScript(phone)}"}
+      end tell
+    `;
+  }
+
+  script += `
+      save
+      return id of newPerson
+    end tell
+  `;
+
+  const id = await runAppleScript(script);
+  return { success: true, id, message: 'Contact created successfully' };
+}
+
+/**
+ * Update a contact
+ * @param {string} contactId - Contact ID
+ * @param {Object} updates - Fields to update
+ * @returns {Promise<Object>} - Result
+ */
+async function updateContact(contactId, { firstName, lastName, organization, jobTitle, email, phone, note }) {
+  let updateCommands = [];
+
+  if (firstName !== undefined) updateCommands.push(`set first name of thePerson to "${escapeAppleScript(firstName || '')}"`);
+  if (lastName !== undefined) updateCommands.push(`set last name of thePerson to "${escapeAppleScript(lastName || '')}"`);
+  if (organization !== undefined) updateCommands.push(`set organization of thePerson to "${escapeAppleScript(organization || '')}"`);
+  if (jobTitle !== undefined) updateCommands.push(`set job title of thePerson to "${escapeAppleScript(jobTitle || '')}"`);
+  if (note !== undefined) updateCommands.push(`set note of thePerson to "${escapeAppleScript(note || '')}"`);
+
+  const script = `
+    tell application "Contacts"
+      set thePerson to person id "${escapeAppleScript(contactId)}"
+      ${updateCommands.join('\n      ')}
+      save
+    end tell
+    return "updated"
+  `;
+
+  await runAppleScript(script);
+  return { success: true, message: 'Contact updated successfully' };
+}
+
+/**
+ * Delete a contact
+ * @param {string} contactId - Contact ID
+ * @returns {Promise<Object>} - Result
+ */
+async function deleteContact(contactId) {
+  const script = `
+    tell application "Contacts"
+      set thePerson to person id "${escapeAppleScript(contactId)}"
+      delete thePerson
+      save
+    end tell
+    return "deleted"
+  `;
+
+  await runAppleScript(script);
+  return { success: true, message: 'Contact deleted successfully' };
+}
+
+/**
+ * List all contact accounts (iCloud, Google, etc.)
+ * @returns {Promise<Array>} - List of accounts
+ */
+async function listAccounts() {
+  const script = `
+    const contacts = Application('Contacts');
+    const accounts = contacts.accounts();
+    let result = [];
+
+    for (let account of accounts) {
+      try {
+        const groups = account.groups();
+        result.push({
+          id: account.id(),
+          name: account.name(),
+          groupCount: groups.length
+        });
+      } catch (e) {
+        result.push({
+          id: account.id(),
+          name: account.name(),
+          groupCount: 0
+        });
+      }
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+/**
+ * List contact groups
+ * @param {string} accountId - Optional account ID to filter by
+ * @returns {Promise<Array>} - List of groups
+ */
+async function listGroups(accountId = null) {
+  const script = accountId ? `
+    const contacts = Application('Contacts');
+    const account = contacts.accounts.byId("${escapeJXA(accountId)}");
+    const groups = account.groups();
+    let result = [];
+
+    for (let group of groups) {
+      try {
+        const people = group.people();
+        result.push({
+          id: group.id(),
+          name: group.name(),
+          accountId: "${escapeJXA(accountId)}",
+          accountName: account.name(),
+          contactCount: people.length
+        });
+      } catch (e) {}
+    }
+
+    JSON.stringify(result);
+  ` : `
+    const contacts = Application('Contacts');
+    const accounts = contacts.accounts();
+    let result = [];
+
+    for (let account of accounts) {
+      try {
+        const groups = account.groups();
+        for (let group of groups) {
+          try {
+            const people = group.people();
+            result.push({
+              id: group.id(),
+              name: group.name(),
+              accountId: account.id(),
+              accountName: account.name(),
+              contactCount: people.length
+            });
+          } catch (e) {}
+        }
+      } catch (e) {}
+    }
+
+    JSON.stringify(result);
+  `;
+
+  const result = await runJXA(script);
+  return result ? JSON.parse(result) : [];
+}
+
+module.exports = {
+  listContacts,
+  searchContacts,
+  readContact,
+  createContact,
+  updateContact,
+  deleteContact,
+  listAccounts,
+  listGroups
+};

package/email/imap-client.js

@@ -0,0 +1,351 @@
+/**
+ * IMAP client wrapper for iCloud Mail
+ */
+
+const Imap = require('imap');
+const { simpleParser } = require('mailparser');
+const config = require('../config');
+const { getCredentials } = require('../auth');
+
+/**
+ * Create IMAP connection
+ */
+function createConnection() {
+  const creds = getCredentials();
+
+  return new Imap({
+    user: creds.email,
+    password: creds.password,
+    host: config.IMAP.HOST,
+    port: config.IMAP.PORT,
+    tls: config.IMAP.TLS,
+    authTimeout: config.IMAP.AUTH_TIMEOUT,
+    connTimeout: config.IMAP.CONN_TIMEOUT
+  });
+}
+
+/**
+ * Execute IMAP operation with connection management
+ */
+function withImap(operation) {
+  return new Promise((resolve, reject) => {
+    const imap = createConnection();
+
+    imap.once('ready', async () => {
+      try {
+        const result = await operation(imap);
+        imap.end();
+        resolve(result);
+      } catch (err) {
+        imap.end();
+        reject(err);
+      }
+    });
+
+    imap.once('error', (err) => {
+      if (err.message?.includes('AUTHENTICATIONFAILED')) {
+        reject(new Error('UNAUTHORIZED'));
+      } else {
+        reject(err);
+      }
+    });
+
+    imap.connect();
+  });
+}
+
+/**
+ * Get folder name from user-friendly name
+ */
+function getFolderName(folder) {
+  const lower = (folder || 'inbox').toLowerCase();
+  return config.EMAIL_FOLDERS[lower] || folder;
+}
+
+/**
+ * List emails from a folder
+ */
+async function listEmails(folder = 'inbox', count = 25) {
+  return withImap(async (imap) => {
+    return new Promise((resolve, reject) => {
+      const folderName = getFolderName(folder);
+
+      imap.openBox(folderName, true, (err, box) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        const total = box.messages.total;
+        if (total === 0) {
+          resolve([]);
+          return;
+        }
+
+        // Fetch most recent emails
+        const start = Math.max(1, total - count + 1);
+        const range = `${start}:${total}`;
+
+        const emails = [];
+        const fetch = imap.seq.fetch(range, {
+          bodies: ['HEADER.FIELDS (FROM TO SUBJECT DATE)'],
+          struct: true
+        });
+
+        fetch.on('message', (msg, seqno) => {
+          const email = { seqno, uid: null };
+
+          msg.on('body', (stream, info) => {
+            let buffer = '';
+            stream.on('data', (chunk) => buffer += chunk.toString('utf8'));
+            stream.on('end', () => {
+              const headers = Imap.parseHeader(buffer);
+              email.from = headers.from?.[0] || '';
+              email.to = headers.to?.[0] || '';
+              email.subject = headers.subject?.[0] || '(No subject)';
+              email.date = headers.date?.[0] || '';
+            });
+          });
+
+          msg.once('attributes', (attrs) => {
+            email.uid = attrs.uid;
+            email.flags = attrs.flags || [];
+          });
+
+          msg.once('end', () => {
+            emails.push(email);
+          });
+        });
+
+        fetch.once('error', reject);
+        fetch.once('end', () => {
+          // Sort by date descending (newest first)
+          emails.sort((a, b) => new Date(b.date) - new Date(a.date));
+          resolve(emails);
+        });
+      });
+    });
+  });
+}
+
+/**
+ * Read full email content
+ */
+async function readEmail(uid, folder = 'inbox') {
+  return withImap(async (imap) => {
+    return new Promise((resolve, reject) => {
+      const folderName = getFolderName(folder);
+
+      imap.openBox(folderName, true, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        const fetch = imap.fetch(uid, { bodies: '' });
+        let rawEmail = '';
+
+        fetch.on('message', (msg) => {
+          msg.on('body', (stream) => {
+            stream.on('data', (chunk) => rawEmail += chunk.toString('utf8'));
+          });
+        });
+
+        fetch.once('error', reject);
+        fetch.once('end', async () => {
+          try {
+            const parsed = await simpleParser(rawEmail);
+            resolve({
+              uid,
+              from: parsed.from?.text || '',
+              to: parsed.to?.text || '',
+              cc: parsed.cc?.text || '',
+              subject: parsed.subject || '(No subject)',
+              date: parsed.date,
+              text: parsed.text || '',
+              html: parsed.html || '',
+              attachments: (parsed.attachments || []).map(a => ({
+                filename: a.filename,
+                contentType: a.contentType,
+                size: a.size
+              }))
+            });
+          } catch (parseErr) {
+            reject(parseErr);
+          }
+        });
+      });
+    });
+  });
+}
+
+/**
+ * Search emails
+ */
+async function searchEmails(criteria, folder = 'inbox', count = 25) {
+  return withImap(async (imap) => {
+    return new Promise((resolve, reject) => {
+      const folderName = getFolderName(folder);
+
+      imap.openBox(folderName, true, (err, box) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        // Build IMAP search criteria
+        const searchCriteria = [];
+
+        if (criteria.from) {
+          searchCriteria.push(['FROM', criteria.from]);
+        }
+        if (criteria.subject) {
+          searchCriteria.push(['SUBJECT', criteria.subject]);
+        }
+        if (criteria.since) {
+          searchCriteria.push(['SINCE', criteria.since]);
+        }
+        if (criteria.before) {
+          searchCriteria.push(['BEFORE', criteria.before]);
+        }
+        if (criteria.unseen) {
+          searchCriteria.push('UNSEEN');
+        }
+        if (criteria.text) {
+          searchCriteria.push(['TEXT', criteria.text]);
+        }
+
+        // Default to ALL if no criteria
+        if (searchCriteria.length === 0) {
+          searchCriteria.push('ALL');
+        }
+
+        imap.search(searchCriteria, (err, uids) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          if (!uids || uids.length === 0) {
+            resolve([]);
+            return;
+          }
+
+          // Get most recent results
+          const recentUids = uids.slice(-count);
+
+          const emails = [];
+          const fetch = imap.fetch(recentUids, {
+            bodies: ['HEADER.FIELDS (FROM TO SUBJECT DATE)'],
+            struct: true
+          });
+
+          fetch.on('message', (msg, seqno) => {
+            const email = { seqno };
+
+            msg.on('body', (stream) => {
+              let buffer = '';
+              stream.on('data', (chunk) => buffer += chunk.toString('utf8'));
+              stream.on('end', () => {
+                const headers = Imap.parseHeader(buffer);
+                email.from = headers.from?.[0] || '';
+                email.to = headers.to?.[0] || '';
+                email.subject = headers.subject?.[0] || '(No subject)';
+                email.date = headers.date?.[0] || '';
+              });
+            });
+
+            msg.once('attributes', (attrs) => {
+              email.uid = attrs.uid;
+              email.flags = attrs.flags || [];
+            });
+
+            msg.once('end', () => {
+              emails.push(email);
+            });
+          });
+
+          fetch.once('error', reject);
+          fetch.once('end', () => {
+            emails.sort((a, b) => new Date(b.date) - new Date(a.date));
+            resolve(emails);
+          });
+        });
+      });
+    });
+  });
+}
+
+/**
+ * Mark email as read/unread
+ */
+async function markAsRead(uid, folder = 'inbox', isRead = true) {
+  return withImap(async (imap) => {
+    return new Promise((resolve, reject) => {
+      const folderName = getFolderName(folder);
+
+      imap.openBox(folderName, false, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        const flags = ['\\Seen'];
+        const method = isRead ? 'addFlags' : 'delFlags';
+
+        imap[method](uid, flags, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(true);
+          }
+        });
+      });
+    });
+  });
+}
+
+/**
+ * List folders
+ */
+async function listFolders() {
+  return withImap(async (imap) => {
+    return new Promise((resolve, reject) => {
+      imap.getBoxes((err, boxes) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        const folders = [];
+
+        function processBoxes(boxObj, prefix = '') {
+          for (const [name, box] of Object.entries(boxObj)) {
+            const fullPath = prefix ? `${prefix}${box.delimiter}${name}` : name;
+            folders.push({
+              name: fullPath,
+              delimiter: box.delimiter,
+              flags: box.attribs || []
+            });
+
+            if (box.children) {
+              processBoxes(box.children, fullPath);
+            }
+          }
+        }
+
+        processBoxes(boxes);
+        resolve(folders);
+      });
+    });
+  });
+}
+
+module.exports = {
+  listEmails,
+  readEmail,
+  searchEmails,
+  markAsRead,
+  listFolders,
+  getFolderName
+};