@marlinjai/email-mcp 1.2.7 → 1.3.0

package/README.md

@@ -103,7 +103,7 @@ npx @marlinjai/email-mcp setup
 # Optionally enter SMTP host and port for sending
 ```
 
-## Available Tools (24)
+## Available Tools (25)
 
 ### Account Management (4)
 
@@ -134,11 +134,12 @@ npx @marlinjai/email-mcp setup
 | `email_draft_create` | Save a draft without sending |
 | `email_draft_list` | List all drafts |
 
-### Organization (7)
+### Organization (8)
 
 | Tool | Description |
 |------|-------------|
 | `email_move` | Move an email to a different folder. Supports `sourceFolder` for IMAP/iCloud |
+| `email_transfer` | Move or copy emails **between accounts**, preserving the original message (sender, date, threading) via raw MIME transfer. `deleteAfter=true` trashes the source only after a confirmed import (safe cross-account move) |
 | `email_delete` | Delete an email (trash or permanent). Supports `sourceFolder` for IMAP/iCloud |
 | `email_mark` | Mark as read/unread, starred, or flagged. Supports `sourceFolder` for IMAP/iCloud |
 | `email_label` | Add/remove labels (Gmail only) |

package/dist/index.js

@@ -7070,6 +7070,7 @@ var init_mapper = __esm({
 });
 
 // src/providers/gmail/adapter.ts
+import { Readable } from "node:stream";
 import { google } from "googleapis";
 import { OAuth2Client } from "google-auth-library";
 var GmailAdapter;
@@ -7129,20 +7130,32 @@ var init_adapter = __esm({
       async search(query) {
         const gmail = this.ensureConnected();
         const q = buildGmailQuery(query);
-        const params = {
-          userId: "me",
-          maxResults: query.limit || 20
-        };
-        if (q) params.q = q;
-        if (query.folder) params.labelIds = [query.folder];
-        const res = await gmail.users.messages.list(params);
-        const messages = res.data.messages || [];
-        if (messages.length === 0) return [];
+        const limit = query.limit || 20;
+        const offset = query.offset || 0;
+        const needed = offset + limit;
+        const ids = [];
+        let pageToken;
+        do {
+          const params = {
+            userId: "me",
+            maxResults: Math.min(500, needed - ids.length)
+          };
+          if (q) params.q = q;
+          if (query.folder) params.labelIds = [query.folder];
+          if (pageToken) params.pageToken = pageToken;
+          const res = await gmail.users.messages.list(params);
+          for (const msg of res.data.messages || []) {
+            if (msg.id) ids.push(msg.id);
+          }
+          pageToken = res.data.nextPageToken || void 0;
+        } while (pageToken && ids.length < needed);
+        const windowIds = ids.slice(offset, offset + limit);
+        if (windowIds.length === 0) return [];
         const emails = [];
-        for (const msg of messages) {
+        for (const id of windowIds) {
           const full = await gmail.users.messages.get({
             userId: "me",
-            id: msg.id,
+            id,
             format: "full"
           });
           emails.push(mapGmailMessage(full.data, this.accountId));
@@ -7390,6 +7403,40 @@ var init_adapter = __esm({
         }
         return result;
       }
+      async getRawMessage(emailId, _sourceFolder) {
+        const gmail = this.ensureConnected();
+        const res = await gmail.users.messages.get({
+          userId: "me",
+          id: emailId,
+          format: "raw"
+        });
+        return Buffer.from(res.data.raw || "", "base64url");
+      }
+      async appendRawMessage(raw, targetFolder, flags) {
+        const gmail = this.ensureConnected();
+        const labelIds = [];
+        labelIds.push(targetFolder ? await this.resolveLabelId(targetFolder) : "INBOX");
+        if (flags?.read === false) labelIds.push("UNREAD");
+        if (flags?.starred === true) labelIds.push("STARRED");
+        const res = await gmail.users.messages.insert({
+          userId: "me",
+          internalDateSource: "dateHeader",
+          requestBody: { labelIds },
+          media: { mimeType: "message/rfc822", body: Readable.from(raw) }
+        });
+        return { id: res.data.id || "" };
+      }
+      /** Resolve a Gmail label name or id to a label id (accepts either). */
+      async resolveLabelId(nameOrId) {
+        const gmail = this.ensureConnected();
+        const res = await gmail.users.labels.list({ userId: "me" });
+        const labels = res.data.labels || [];
+        const byId = labels.find((l) => l.id === nameOrId);
+        if (byId?.id) return byId.id;
+        const byName = labels.find((l) => (l.name || "").toLowerCase() === nameOrId.toLowerCase());
+        if (byName?.id) return byName.id;
+        return nameOrId;
+      }
       async addLabels(emailId, labels) {
         const gmail = this.ensureConnected();
         await gmail.users.messages.modify({
@@ -7848,6 +7895,41 @@ var init_adapter2 = __esm({
           destinationId
         });
       }
+      async getRawMessage(emailId, _sourceFolder) {
+        this.ensureClient();
+        const res = await fetch(
+          `https://graph.microsoft.com/v1.0/me/messages/${encodeURIComponent(emailId)}/$value`,
+          { headers: { Authorization: `Bearer ${this.accessToken}` } }
+        );
+        if (!res.ok) {
+          throw new Error(`Graph $value fetch failed for ${emailId}: HTTP ${res.status}`);
+        }
+        return Buffer.from(await res.arrayBuffer());
+      }
+      async appendRawMessage(raw, targetFolder, flags) {
+        this.ensureClient();
+        const endpoint = targetFolder ? `https://graph.microsoft.com/v1.0/me/mailFolders/${encodeURIComponent(await this.resolveFolder(targetFolder))}/messages` : "https://graph.microsoft.com/v1.0/me/messages";
+        const res = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`,
+            "Content-Type": "text/plain"
+          },
+          body: raw.toString("base64")
+        });
+        if (!res.ok) {
+          const detail = await res.text().catch(() => "");
+          throw new Error(`Graph MIME import failed: HTTP ${res.status} ${detail.slice(0, 200)}`);
+        }
+        const data = await res.json().catch(() => ({}));
+        if (flags && data.id && (flags.read !== void 0 || flags.starred !== void 0)) {
+          try {
+            await this.markEmail(data.id, flags);
+          } catch {
+          }
+        }
+        return { id: data.id || "" };
+      }
       async deleteEmail(emailId, permanent, _sourceFolder) {
         const client = this.ensureClient();
         if (permanent) {
@@ -8399,14 +8481,7 @@ var init_adapter3 = __esm({
         }
         try {
           const mailboxExists = this.client.mailbox?.exists ?? 0;
-          let statusCount = 0;
-          try {
-            const status = await this.client.status(folder, { messages: true });
-            statusCount = status.messages ?? 0;
-          } catch {
-          }
-          const effectiveCount = Math.max(mailboxExists, statusCount);
-          if (effectiveCount === 0) {
+          if (mailboxExists === 0) {
             return [];
           }
           const criteria = this.buildSearchCriteria(query);
@@ -8419,7 +8494,11 @@ var init_adapter3 = __esm({
             );
             allUids = Array.isArray(searchResult) ? searchResult : [];
           } catch {
-            allUids = await this.collectUidsViaFetch(query);
+            try {
+              allUids = await this.collectUidsViaFetch(query);
+            } catch {
+              return [];
+            }
           }
           const offset = query.offset || 0;
           const slicedUids = query.limit ? allUids.slice(offset, offset + query.limit) : allUids.slice(offset);
@@ -8481,19 +8560,27 @@ var init_adapter3 = __esm({
       async fetchEmails(uids, folder, returnBody) {
         if (!this.client) return [];
         const emails = [];
-        if (returnBody) {
-          for await (const msg of this.client.fetch(uids, { source: true, uid: true, flags: true })) {
+        const fetchOpts = returnBody ? { source: true, uid: true, flags: true } : { envelope: true, uid: true, flags: true, bodyStructure: true };
+        const uidRange = uids.join(",");
+        let messages;
+        try {
+          messages = await this.client.fetchAll(uidRange, fetchOpts, { uid: true });
+        } catch {
+          messages = [];
+          for (const uid of uids) {
+            try {
+              const batch = await this.client.fetchAll(String(uid), fetchOpts, { uid: true });
+              messages.push(...batch);
+            } catch {
+            }
+          }
+        }
+        for (const msg of messages) {
+          if (returnBody) {
             const parsed = await simpleParser(msg.source);
             parsed.flags = msg.flags;
             emails.push(mapParsedEmail(parsed, folder, this.accountId, msg.uid));
-          }
-        } else {
-          for await (const msg of this.client.fetch(uids, {
-            envelope: true,
-            uid: true,
-            flags: true,
-            bodyStructure: true
-          })) {
+          } else {
             const env = msg.envelope;
             emails.push({
               id: String(msg.uid),
@@ -8702,6 +8789,32 @@ var init_adapter3 = __esm({
           lock.release();
         }
       }
+      async getRawMessage(emailId, sourceFolder) {
+        if (!this.client) throw new Error("Not connected");
+        const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
+        let lock;
+        try {
+          lock = await this.client.getMailboxLock(folder);
+        } catch (error48) {
+          throw formatImapError(error48, `Failed to open folder "${folder}"`);
+        }
+        try {
+          const msg = await this.client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
+          if (!msg || !msg.source) throw new Error(`Email ${emailId} not found in "${folder}"`);
+          return msg.source;
+        } finally {
+          lock.release();
+        }
+      }
+      async appendRawMessage(raw, targetFolder, flags) {
+        if (!this.client) throw new Error("Not connected");
+        const folder = targetFolder ? await this.resolveFolder(targetFolder) : "INBOX";
+        const imapFlags = [];
+        if (flags?.read) imapFlags.push("\\Seen");
+        if (flags?.starred) imapFlags.push("\\Flagged");
+        const result = await this.client.append(folder, raw, imapFlags);
+        return { id: String(result?.uid ?? "") };
+      }
       async batchDelete(emailIds, permanent, sourceFolder) {
         if (!this.client) throw new Error("Not connected");
         const result = { succeeded: [], failed: [] };
@@ -33222,6 +33335,66 @@ function registerOrganizingTools(server, accountManager) {
       }
     }
   );
+  server.tool(
+    "email_transfer",
+    "Move or copy emails BETWEEN accounts, preserving the original message intact (sender, date, threading) by transferring the raw MIME. Fetches each message from the source account and imports it into the target account. With deleteAfter=true the source copy is sent to trash only after a confirmed import, making this a safe cross-account move.",
+    {
+      sourceAccountId: external_exports3.string().describe("Account to read messages from"),
+      targetAccountId: external_exports3.string().describe("Account to import messages into"),
+      emailIds: external_exports3.array(external_exports3.string()).min(1).describe("Source email IDs to transfer"),
+      targetFolder: external_exports3.string().optional().describe("Destination folder/label in the target account (Gmail label id or name; IMAP/Outlook folder name). Defaults to INBOX."),
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when emails are not in INBOX)"),
+      deleteAfter: external_exports3.boolean().optional().describe("Send the source copy to trash after a successful import. Default false (copy, leaving the original in place)."),
+      markRead: external_exports3.boolean().optional().describe("Mark imported messages as read in the target. Default: provider default (usually unread).")
+    },
+    async (args) => {
+      try {
+        const source = await accountManager.getProvider(args.sourceAccountId);
+        const target = await accountManager.getProvider(args.targetAccountId);
+        if (!source.getRawMessage) {
+          return jsonResult4({ success: false, error: "Source provider does not support raw message export" });
+        }
+        if (!target.appendRawMessage) {
+          return jsonResult4({ success: false, error: "Target provider does not support raw message import" });
+        }
+        const flags = args.markRead !== void 0 ? { read: args.markRead } : void 0;
+        const transferred = [];
+        const failed = [];
+        const deleted = [];
+        const deleteFailed = [];
+        for (const id of args.emailIds) {
+          let targetId;
+          try {
+            const raw = await source.getRawMessage(id, args.sourceFolder);
+            const res = await target.appendRawMessage(raw, args.targetFolder, flags);
+            targetId = res.id;
+            transferred.push({ sourceId: id, targetId });
+          } catch (e) {
+            failed.push({ id, error: e.message });
+            continue;
+          }
+          if (args.deleteAfter) {
+            try {
+              await source.deleteEmail(id, false, args.sourceFolder);
+              deleted.push(id);
+            } catch (e) {
+              deleteFailed.push({ id, error: e.message });
+            }
+          }
+        }
+        return jsonResult4({
+          success: true,
+          transferred: transferred.length,
+          deleted: deleted.length,
+          ...failed.length ? { failedCount: failed.length } : {},
+          ...deleteFailed.length ? { deleteFailedCount: deleteFailed.length } : {},
+          details: { transferred, failed, deleted, deleteFailed }
+        });
+      } catch (error48) {
+        return jsonResult4({ success: false, error: error48.message });
+      }
+    }
+  );
   server.tool(
     "email_label",
     "Add or remove labels on an email (Gmail only)",