@lengelhard/imap-email-mcp 1.9.1 → 1.9.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.9.2
+
+### Fixed
+- `move_email` and `move_thread` no longer create a duplicate when the destination already holds the message. A mail client that files by label can leave the same message in INBOX and in the label's folder at once; moving the INBOX copy then held it twice in the destination (seen on 25 Sep 2026 after a scheduled inbox sweep). The move now checks the destination for the same Message-ID first: if found, the source copy is removed instead of copied, and the response says `action: "already_present"` (`move_email`) or lists `already_present` (`move_thread`). A message with no Message-ID is moved the plain way.
+- `references` is no longer returned by `list_emails`, `search_emails` and `search_index`. On long threads it was 20 to 30 Message-IDs per message, several times the size of the rest of the result, and the tasks that read listings never use it. It stays on `get_email`, and `find_split_threads` threads on it as before. `in_reply_to` stays everywhere.
+
 ## 1.9.1
 
 ### Fixed

package/README.md

@@ -163,6 +163,8 @@ A conversation can end up spread across folders without any message being duplic
 | `sync_index` | Run an index sync now; `force: true` aborts a stuck sync first |
 | `find_duplicates` | Messages that exist more than once, matched on Message-ID: filed twice in one folder, or spread across folders |
 | `find_split_threads` | Conversations spread across folders, threaded on In-Reply-To and References so renamed replies stay with their thread |
+| `move_email` | Move one message by UID. If the destination already holds it (same Message-ID) the source copy is removed instead, never duplicated |
+| `move_thread` | Move every message of a thread by subject in one call, with the same duplicate-safe behaviour |
 | `list_drafts` | List all draft emails |
 | `get_draft` | Get a specific draft by UID |
 | `create_draft` | Create a new email draft |

package/index.js

@@ -23,6 +23,7 @@ import os from 'os';
 import { createRequire } from 'module';
 import {
   setOpTimeout,
+  withTimeout,
   SessionManager,
   openBox,
   queryUids,
@@ -787,7 +788,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'move_email',
-        description: 'Move an email from one folder to another (e.g. Inbox → Action, Waiting, Delegated, Hold)',
+        description: 'Move an email from one folder to another (e.g. Inbox → Action, Waiting, Delegated, Hold). If the destination already holds the same message (same Message-ID, as when a mail client filed it there by label), the source copy is removed instead of copied and the response says action: "already_present", so a move never creates a duplicate.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -856,7 +857,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'move_thread',
-        description: 'Move an entire email thread (all messages matching a subject) from one folder to another in a single call. Strips Re:/Fwd: prefixes for matching. Use move_email for single-message precision moves.',
+        description: 'Move an entire email thread (all messages matching a subject) from one folder to another in a single call. Strips Re:/Fwd: prefixes for matching. Messages the destination already holds (same Message-ID) are removed from the source instead of copied, reported under already_present, so a move never creates a duplicate. Use move_email for single-message precision moves.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -910,7 +911,67 @@ async function connectIMAP() {
   return await sessions.acquire();
 }
 
-const LIST_HEADER_FIELDS = 'HEADER.FIELDS (FROM TO CC SUBJECT DATE MESSAGE-ID IN-REPLY-TO REFERENCES)';
+/**
+ * Move UIDs from the open folder `fromFolder` to `toFolder` without creating a
+ * second copy. A mail client that files by label can leave the same message in
+ * both folders already (the INBOX copy of a message also tagged "Deal Flow"),
+ * and a plain MOVE would then hold it twice in the destination. When the
+ * destination already has a message with the same Message-ID, the source copy
+ * is removed instead of copied, which is what a move means anyway.
+ * Returns one entry per uid: { uid, action: 'moved' | 'already_present' | 'failed', ... }.
+ * Leaves `fromFolder` open when done.
+ */
+async function moveWithoutDuplicates(connection, fromFolder, uids, toFolder) {
+  const parseHeader = connection.imap.constructor.parseHeader;
+  const idsByUid = new Map();
+  try {
+    const fetched = await fetchMessages(connection, uids, { bodies: ['HEADER.FIELDS (MESSAGE-ID)'] });
+    for (const [uid, rec] of fetched) {
+      const id = normalizeMessageId(headerOf(rec, parseHeader)['message-id']?.[0]);
+      if (id) idsByUid.set(Number(uid), id);
+    }
+  } catch { /* no ids: every uid is moved the plain way */ }
+
+  // Which of these Message-IDs does the destination already hold?
+  const present = new Map();
+  if (idsByUid.size) {
+    try {
+      await openBox(connection, toFolder, true);
+      for (const [uid, id] of idsByUid) {
+        const found = await queryUids(connection, [['HEADER', 'MESSAGE-ID', id]]);
+        if (found.length) present.set(uid, found[0]);
+      }
+    } catch { /* destination unreadable: fall through to plain moves, the MOVE itself will report */ }
+    await openBox(connection, fromFolder, false);
+  }
+
+  const results = [];
+  for (const uid of uids) {
+    try {
+      if (present.has(uid)) {
+        await withTimeout(connection, `remove ${uid}`, new Promise((resolve, reject) => {
+          connection.imap.addFlags(uid, ['\\Deleted'], (err) => {
+            if (err) return reject(err);
+            connection.imap.expunge(uid, (e) => (e ? reject(e) : resolve()));
+          });
+        }));
+        results.push({ uid, action: 'already_present', existing_uid: present.get(uid), message_id: idsByUid.get(uid) });
+      } else {
+        await withTimeout(connection, `move ${uid}`, new Promise((resolve, reject) => {
+          connection.imap.move(uid, toFolder, (err) => (err ? reject(err) : resolve()));
+        }));
+        results.push({ uid, action: 'moved' });
+      }
+    } catch (err) {
+      results.push({ uid, action: 'failed', error: err.message });
+    }
+  }
+  return results;
+}
+
+// References is not fetched here: on long threads it is 20 to 30 ids per message and
+// listings are read by tasks that never use it. get_email and find_split_threads carry it.
+const LIST_HEADER_FIELDS = 'HEADER.FIELDS (FROM TO CC SUBJECT DATE MESSAGE-ID IN-REPLY-TO)';
 const MAX_LIMIT = 200;
 
 function clampLimit(value, fallback = 20) {
@@ -941,8 +1002,6 @@ async function summarize(connection, folder, uids, { withFlags = true } = {}) {
     if (messageId) item.message_id = messageId;
     const inReplyTo = parseMessageIdList(h['in-reply-to'])[0];
     if (inReplyTo) item.in_reply_to = inReplyTo;
-    const references = parseMessageIdList(h.references);
-    if (references.length) item.references = references;
     if (withFlags) item.flags = rec.attributes.flags;
     out.push(item);
   }
@@ -1787,12 +1846,8 @@ async function handleTool(name, args) {
         try {
           await connection.openBox(fromFolder);
 
-          await new Promise((resolve, reject) => {
-            connection.imap.move(args.uid, toFolder, (err) => {
-              if (err) reject(err);
-              else resolve();
-            });
-          });
+          const [r] = await moveWithoutDuplicates(connection, fromFolder, [Number(args.uid)], toFolder);
+          if (r.action === 'failed') throw new Error(r.error);
 
           return {
             content: [{
@@ -1801,7 +1856,12 @@ async function handleTool(name, args) {
                 success: true,
                 uid: args.uid,
                 from: fromFolder,
-                to: toFolder
+                to: toFolder,
+                action: r.action,
+                ...(r.action === 'already_present' && {
+                  existing_uid: r.existing_uid,
+                  note: `${toFolder} already held this message (same Message-ID) as uid ${r.existing_uid}; the ${fromFolder} copy was removed instead of copied, so it is not duplicated.`
+                })
               }, null, 2)
             }]
           };
@@ -1940,22 +2000,12 @@ async function handleTool(name, args) {
             };
           }
 
-          // Move each matching UID using the same imap.move() pattern as move_email
-          let moved = 0;
-          const failures = [];
-          for (const uid of matchingUIDs) {
-            try {
-              await new Promise((resolve, reject) => {
-                connection.imap.move(uid, to_folder, (err) => {
-                  if (err) reject(err);
-                  else resolve();
-                });
-              });
-              moved++;
-            } catch (moveErr) {
-              failures.push({ uid, error: moveErr.message });
-            }
-          }
+          // Move each matching UID; a message the destination already holds is
+          // removed from the source instead of copied a second time.
+          const results = await moveWithoutDuplicates(connection, from_folder, matchingUIDs.map(Number), to_folder);
+          const moved = results.filter((r) => r.action === 'moved').length;
+          const alreadyPresent = results.filter((r) => r.action === 'already_present');
+          const failures = results.filter((r) => r.action === 'failed').map((r) => ({ uid: r.uid, error: r.error }));
 
           return {
             content: [{
@@ -1963,11 +2013,16 @@ async function handleTool(name, args) {
               text: JSON.stringify({
                 success: failures.length === 0,
                 moved,
+                already_present: alreadyPresent.length,
                 failed: failures.length,
                 total_found: matchingUIDs.length,
                 from_folder,
                 to_folder,
                 subject: normalizedTarget,
+                ...(alreadyPresent.length > 0 && {
+                  already_present_uids: alreadyPresent.map((r) => ({ uid: r.uid, existing_uid: r.existing_uid })),
+                  note: `${alreadyPresent.length} message(s) were already in ${to_folder} (same Message-ID); their ${from_folder} copies were removed instead of copied, so nothing is duplicated.`
+                }),
                 ...(failures.length > 0 && { failures })
               }, null, 2)
             }]

package/lib/local-index.js

@@ -1106,7 +1106,7 @@ export class LocalIndex {
     const total = this.db.prepare(`SELECT count(*) AS n FROM fts JOIN messages m ON m.id = fts.rowid WHERE ${whereSql}`).get(...params).n;
     const rows = this.db.prepare(`
       SELECT m.folder, m.uid, m.internal_date, m.sent_date, m.from_addr, m.to_addr, m.subject, m.attachments, m.message_id,
-             m.in_reply_to, m.references_ids,
+             m.in_reply_to,
              snippet(fts, -1, '[', ']', '...', 16) AS snippet
       FROM fts JOIN messages m ON m.id = fts.rowid
       WHERE ${whereSql}
@@ -1127,7 +1127,6 @@ export class LocalIndex {
         subject: r.subject,
         message_id: normalizeMessageId(r.message_id) || undefined,
         in_reply_to: r.in_reply_to || undefined,
-        references: r.references_ids ? r.references_ids.split(' ') : undefined,
         attachments: r.attachments || undefined,
         snippet: r.snippet
       }))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lengelhard/imap-email-mcp",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "MCP server for Claude Code that provides email capabilities through IMAP/SMTP. Read, search, compose, and manage emails from any IMAP provider.",
   "type": "module",
   "main": "index.js",