proton-mail-bridge-client 2.0.2 → 2.0.4

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AASA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAYnE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAA2H,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC/L,OAAO,EAAkB,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE7D,OAAO,KAAK,EAUV,WAAW,EAEX,gBAAgB,EAEjB,MAAM,kBAAkB,CAAC;AA2qD1B,eAAO,MAAM,eAAe,aAyB1B,CAAC;AAgGH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAmED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK3G;AAKD,wBAAgB,0BAA0B,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAI1G;AASD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAa9E;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAS7F;AA4KD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,OAAO,GAChB;IAAE,EAAE,EAAE,MAAM,EAAE,CAAC;IAAC,EAAE,EAAE,MAAM,EAAE,CAAA;CAAE,CAyBhC;AA4wBD,wBAAgB,kBAAkB,IAAI,gBAAgB,CAkGrD;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE;IACP,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA07FP;AAED,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAmE1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AASA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAYnE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAA2H,iBAAiB,EAA+B,MAAM,mCAAmC,CAAC;AAC5N,OAAO,EAAkB,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE7D,OAAO,KAAK,EAUV,WAAW,EAEX,gBAAgB,EAEjB,MAAM,kBAAkB,CAAC;AA2qD1B,eAAO,MAAM,eAAe,aAyB1B,CAAC;AAgGH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAmED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK3G;AAKD,wBAAgB,0BAA0B,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAI1G;AASD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAa9E;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAS7F;AA4KD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,OAAO,GAChB;IAAE,EAAE,EAAE,MAAM,EAAE,CAAC;IAAC,EAAE,EAAE,MAAM,EAAE,CAAA;CAAE,CAyBhC;AAwzBD,wBAAgB,kBAAkB,IAAI,gBAAgB,CAkGrD;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE;IACP,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqhGP;AAED,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAmE1C"}

package/dist/index.js

@@ -16,7 +16,7 @@ import { BackgroundSyncService } from "./services/background-sync-service.js";
 import { DeliveryQueueService } from "./services/delivery-queue-service.js";
 import { DraftStoreService } from "./services/draft-store-service.js";
 import { LocalIndexService } from "./services/local-index-service.js";
-import { BULK_ITEM_TIMEOUT_MS, describeImapError, isLikelyAuthenticationError, isLikelyConnectionError, isLikelyTlsMismatchError, SimpleIMAPService } from "./services/simple-imap-service.js";
+import { BULK_ITEM_TIMEOUT_MS, describeImapError, isLikelyAuthenticationError, isLikelyConnectionError, isLikelyTlsMismatchError, SimpleIMAPService, UID_VALIDITY_MISMATCH_ERROR } from "./services/simple-imap-service.js";
 import { applySignature, SMTPService } from "./services/smtp-service.js";
 import { SnoozeService } from "./services/snooze-service.js";
 import { TemplateService } from "./services/template-service.js";
@@ -2370,27 +2370,32 @@ async function getAnalyticsSampleFromIndex(imapService, localIndexService, days,
     return result.emails;
 }
 async function runEmailAction(imapService, emailId, action, targetFolder) {
+    // undefined for an old-format id (no embedded UIDVALIDITY) — every method
+    // below's own assertMailboxUidValidity guard already treats that as
+    // "unverifiable, don't block on it", same as every direct single-message
+    // tool handler.
+    const uidValidity = parseEmailId(emailId).uidValidity;
     switch (action) {
         case "mark_read":
-            return imapService.markEmailRead(emailId, true);
+            return imapService.markEmailRead(emailId, true, uidValidity);
         case "mark_unread":
-            return imapService.markEmailRead(emailId, false);
+            return imapService.markEmailRead(emailId, false, uidValidity);
         case "star":
-            return imapService.starEmail(emailId, true);
+            return imapService.starEmail(emailId, true, uidValidity);
         case "unstar":
-            return imapService.starEmail(emailId, false);
+            return imapService.starEmail(emailId, false, uidValidity);
         case "archive":
-            return imapService.archiveEmail(emailId);
+            return imapService.archiveEmail(emailId, uidValidity);
         case "trash":
-            return imapService.trashEmail(emailId);
+            return imapService.trashEmail(emailId, uidValidity);
         case "restore":
-            return imapService.restoreEmail(emailId, targetFolder);
+            return imapService.restoreEmail(emailId, targetFolder, uidValidity);
         case "move":
             if (!targetFolder)
                 throw new McpError(ErrorCode.InvalidParams, "targetFolder is required for action 'move'.");
-            return imapService.moveEmail(emailId, targetFolder);
+            return imapService.moveEmail(emailId, targetFolder, uidValidity);
         case "delete":
-            return imapService.deleteEmail(emailId);
+            return imapService.deleteEmail(emailId, uidValidity);
     }
 }
 function emailSourceFromActionResult(result) {
@@ -2501,11 +2506,19 @@ function ensureBulkBatchSize(uidsLength, max) {
         throw new McpError(ErrorCode.InvalidParams, "Batch size " + uidsLength + " exceeds limit " + max + ". Use match criteria to narrow the scope, or increase maxBatchSize.");
     }
 }
-function getBulkNotFoundEmailIds(emailIds, folder) {
+// `currentUidValidity` is optional and, when omitted, preserves the exact
+// original behavior (folder/format check only) — every caller that already
+// knows the folder's current UIDVALIDITY (the bulk_delete/bulk_update_flags/
+// bulk_update_labels handlers below, via a single shared getMailboxUidValidity
+// call reused for both this and resolveUidsForBulkOp) should pass it, so a
+// stale-generation id gets its own clear error instead of being lumped in
+// with a genuinely malformed one.
+function getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity) {
     if (!emailIds) {
         return [];
     }
-    return emailIds.filter((emailId) => {
+    const excluded = [];
+    for (const emailId of emailIds) {
         // Found live: this compared the emailId's folder segment against
         // `folder` as raw, still-percent-encoded text — createEmailId encodes
         // it (Folders/MCP-Snoozed -> Folders%2FMCP-Snoozed) but `folder` here
@@ -2516,30 +2529,50 @@ function getBulkNotFoundEmailIds(emailIds, folder) {
         // reported genuinely valid ids as notFound. parseEmailId already does
         // the matching decodeURIComponent correctly — reuse it instead of
         // hand-rolling the same parse a second, inconsistent way.
+        let parsed;
         try {
-            const parsed = parseEmailId(emailId);
-            return parsed.folder !== folder;
+            parsed = parseEmailId(emailId);
         }
         catch {
-            return true;
+            excluded.push({ emailId, error: "Email ID could not be resolved to a UID." });
+            continue;
         }
-    });
+        if (parsed.folder !== folder) {
+            excluded.push({ emailId, error: "Email ID could not be resolved to a UID." });
+            continue;
+        }
+        // An id with no embedded uidValidity (pre-this-fix format) is
+        // unverifiable, not stale — same "can't check it, so don't block on
+        // it" stance assertMailboxUidValidity already takes for the
+        // single-message mutation path. Only a *checkable* mismatch is
+        // treated as a stale reference. resolveUidsForBulkOp applies this
+        // exact same exclusion (see its own comment) against the exact same
+        // currentUidValidity value, so the uid this method silently drops from
+        // execution and the id this method reports as excluded here always
+        // agree.
+        if (currentUidValidity !== undefined &&
+            parsed.uidValidity !== undefined &&
+            parsed.uidValidity !== currentUidValidity) {
+            excluded.push({ emailId, error: UID_VALIDITY_MISMATCH_ERROR });
+        }
+    }
+    return excluded;
 }
-function withBulkNotFound(result, notFoundEmailIds) {
-    if (notFoundEmailIds.length === 0) {
+function withBulkNotFound(result, excludedEmailIds) {
+    if (excludedEmailIds.length === 0) {
         return result;
     }
     return {
         ...result,
-        total: result.total + notFoundEmailIds.length,
-        notFound: result.notFound + notFoundEmailIds.length,
+        total: result.total + excludedEmailIds.length,
+        notFound: result.notFound + excludedEmailIds.length,
         results: [
             ...result.results,
-            ...notFoundEmailIds.map((emailId) => ({
+            ...excludedEmailIds.map(({ emailId, error }) => ({
                 uid: 0,
                 emailId,
                 ok: false,
-                error: "Email ID could not be resolved to a UID.",
+                error,
             })),
         ],
     };
@@ -3689,9 +3722,20 @@ export function createServer(config, options = {}) {
                     // lock and flips "draft" -> "sending" in that same critical
                     // section — only the call that wins the claim proceeds to SMTP.
                     await draftStore.claimForSending(draft.id);
+                    // Found live: withAudit wrapped the SMTP call, so an audit-log
+                    // write failure AFTER a successful send (e.g. disk full) was
+                    // indistinguishable from a send failure — it threw out of
+                    // withAudit, and the catch below reverted an already-sent draft
+                    // back to "draft", making it resendable and enabling a genuine
+                    // duplicate delivery. SMTP is called directly here so its outcome
+                    // (and the revert-on-failure below) can't be corrupted by a
+                    // separate audit-write failure — the audit record for the success
+                    // case is written afterward, on its own, with a failure there only
+                    // logged, never reverting a send that already happened.
+                    const sendStartedAt = Date.now();
                     let result;
                     try {
-                        result = await withAudit(auditService, name, args, async () => smtpService.sendEmail({
+                        result = await smtpService.sendEmail({
                             to: draft.to,
                             cc: draft.cc,
                             bcc: draft.bcc,
@@ -3708,15 +3752,41 @@ export function createServer(config, options = {}) {
                             // saw and approved. If a signature is wanted, it belongs in the
                             // draft body itself.
                             appendSignature: false,
-                        }));
+                        });
                     }
                     catch (error) {
                         // Mirrors SnoozeService.wake()'s catch handler: revert the claim
                         // so the draft is retryable instead of stuck in "sending"
                         // forever because SMTP failed.
                         await draftStore.revertSending(draft.id);
+                        await auditService
+                            .record({
+                            timestamp: new Date().toISOString(),
+                            tool: name,
+                            status: "error",
+                            durationMs: Date.now() - sendStartedAt,
+                            input: sanitizeAuditValue(args),
+                            error: error instanceof Error ? error.message : String(error),
+                        })
+                            .catch((auditError) => logger.error("Failed to record audit log for a failed send_draft", "MCPServer", {
+                            draftId: draft.id,
+                            error: auditError,
+                        }));
                         throw error;
                     }
+                    try {
+                        await auditService.record({
+                            timestamp: new Date().toISOString(),
+                            tool: name,
+                            status: "success",
+                            durationMs: Date.now() - sendStartedAt,
+                            input: sanitizeAuditValue(args),
+                            result: sanitizeAuditValue(result),
+                        });
+                    }
+                    catch (auditError) {
+                        logger.error("Failed to record audit log for a successful send_draft — the email was already sent, so the draft is not being reverted", "MCPServer", { draftId: draft.id, error: auditError });
+                    }
                     let sentDraft = await draftStore.markSent(draft.id, {
                         messageId: result.messageId,
                         accepted: result.accepted,
@@ -3961,7 +4031,12 @@ export function createServer(config, options = {}) {
                     if (labelsToAdd.length === 0 && labelsToRemove.length === 0) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide at least one label in labelsToAdd or labelsToRemove.");
                     }
-                    const result = await withAudit(auditService, name, args, async () => imapService.updateMessageLabels(emailId, labelsToAdd, labelsToRemove));
+                    // undefined for an old-format id (no embedded UIDVALIDITY) —
+                    // updateMessageLabels's own assertMailboxUidValidity guard already
+                    // treats that as "unverifiable, don't block on it", same as every
+                    // other mutation handler below.
+                    const uidValidity = parseEmailId(emailId).uidValidity;
+                    const result = await withAudit(auditService, name, args, async () => imapService.updateMessageLabels(emailId, labelsToAdd, labelsToRemove, uidValidity));
                     return createTextResult(result, false, [emailSource({ id: emailId })]);
                 }
                 case "update_message_flags": {
@@ -3976,7 +4051,8 @@ export function createServer(config, options = {}) {
                     if (flagsToAdd.length === 0 && flagsToRemove.length === 0) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide at least one flag in flagsToAdd or flagsToRemove.");
                     }
-                    const result = await withAudit(auditService, name, args, async () => imapService.updateMessageFlags(emailId, flagsToAdd, flagsToRemove));
+                    const uidValidity = parseEmailId(emailId).uidValidity;
+                    const result = await withAudit(auditService, name, args, async () => imapService.updateMessageFlags(emailId, flagsToAdd, flagsToRemove, uidValidity));
                     return createTextResult(result, false, [emailSource({ id: emailId })]);
                 }
                 case "count_messages": {
@@ -4039,7 +4115,12 @@ export function createServer(config, options = {}) {
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const targetFolder = requireString(args, "targetFolder");
                     const max = getBulkMaxBatchSize(args);
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder);
+                    // Only fetched (an extra STATUS round trip) when there are ids to
+                    // check against it — a match-only bulk_move has no ids that could
+                    // be stale, since match resolves directly against the live
+                    // mailbox each time.
+                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
+                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
                     const preview = await imapService.bulkMove({
                         emailIds,
                         match,
@@ -4077,12 +4158,22 @@ export function createServer(config, options = {}) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide emailIds OR match, not both.");
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const max = getBulkMaxBatchSize(args);
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder);
+                    // Fetched once, up front, and reused for both the notFound
+                    // reporting below and resolveUidsForBulkOp's own filtering — a
+                    // single shared point-in-time value, same "resolve once" spirit
+                    // as the uids resolution itself, so the ids this call reports as
+                    // excluded and the uids it actually acts on can never disagree
+                    // about which generation was current. Only fetched when there are
+                    // ids to check against it (a match-only call has none).
+                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
+                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
                     // Resolve the match/emailIds set exactly once and reuse it for both
                     // the preview and the real run — see resolveUidsForBulkOp's
                     // comment for why re-resolving `match` a second time (the old
                     // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match);
+                    // Also excludes any id whose embedded UIDVALIDITY is stale — see
+                    // resolveUidsForBulkOp's comment.
+                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
                     ensureBulkBatchSize(uids.length, max);
                     if (normalizeBoolean(args.dryRun, false)) {
                         const preview = await imapService.bulkDelete({
@@ -4091,6 +4182,7 @@ export function createServer(config, options = {}) {
                             folder,
                             permanent,
                             resolvedUids: uids,
+                            uidValidity: currentUidValidity,
                             dryRun: true,
                         });
                         return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
@@ -4101,6 +4193,7 @@ export function createServer(config, options = {}) {
                         folder,
                         permanent,
                         resolvedUids: uids,
+                        uidValidity: currentUidValidity,
                         dryRun: false,
                     }));
                     return createTextResult(withBulkNotFound(result, notFoundEmailIds));
@@ -4123,18 +4216,22 @@ export function createServer(config, options = {}) {
                         throw new McpError(ErrorCode.InvalidParams, "Provide flagsToAdd or flagsToRemove.");
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const max = getBulkMaxBatchSize(args);
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder);
+                    // See the bulk_delete case above for why this is fetched once and
+                    // shared between notFound reporting and uid resolution.
+                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
+                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
                     // Resolve the match/emailIds set exactly once and reuse it for both
                     // the preview and the real run — see resolveUidsForBulkOp's
                     // comment for why re-resolving `match` a second time (the old
                     // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match);
+                    // Also excludes any id whose embedded UIDVALIDITY is stale.
+                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
                     ensureBulkBatchSize(uids.length, max);
                     if (normalizeBoolean(args.dryRun, false)) {
-                        const preview = await imapService.bulkUpdateFlags({ emailIds, match, folder, flagsToAdd, flagsToRemove, resolvedUids: uids, dryRun: true });
+                        const preview = await imapService.bulkUpdateFlags({ emailIds, match, folder, flagsToAdd, flagsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: true });
                         return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
                     }
-                    const result = await withAudit(auditService, name, args, () => imapService.bulkUpdateFlags({ emailIds, match, folder, flagsToAdd, flagsToRemove, resolvedUids: uids, dryRun: false }));
+                    const result = await withAudit(auditService, name, args, () => imapService.bulkUpdateFlags({ emailIds, match, folder, flagsToAdd, flagsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: false }));
                     return createTextResult(withBulkNotFound(result, notFoundEmailIds));
                 }
                 case "bulk_update_labels": {
@@ -4153,18 +4250,22 @@ export function createServer(config, options = {}) {
                     const labelsToRemove = Array.isArray(args.labelsToRemove) ? args.labelsToRemove.map(String) : [];
                     const folder = optionalString(args, "folder") ?? "INBOX";
                     const max = getBulkMaxBatchSize(args);
-                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder);
+                    // See the bulk_delete case above for why this is fetched once and
+                    // shared between notFound reporting and uid resolution.
+                    const currentUidValidity = emailIds ? await imapService.getMailboxUidValidity(folder) : undefined;
+                    const notFoundEmailIds = getBulkNotFoundEmailIds(emailIds, folder, currentUidValidity);
                     // Resolve the match/emailIds set exactly once and reuse it for both
                     // the preview and the real run — see resolveUidsForBulkOp's
                     // comment for why re-resolving `match` a second time (the old
                     // dry-run-then-real-run pattern) could silently exceed maxBatchSize.
-                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match);
+                    // Also excludes any id whose embedded UIDVALIDITY is stale.
+                    const uids = await imapService.resolveUidsForBulkOp(folder, emailIds, match, currentUidValidity);
                     ensureBulkBatchSize(uids.length, max);
                     if (normalizeBoolean(args.dryRun, false)) {
-                        const preview = await imapService.bulkUpdateLabels({ emailIds, match, folder, labelsToAdd, labelsToRemove, resolvedUids: uids, dryRun: true });
+                        const preview = await imapService.bulkUpdateLabels({ emailIds, match, folder, labelsToAdd, labelsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: true });
                         return createTextResult(withBulkNotFound(preview, notFoundEmailIds));
                     }
-                    const result = await withAudit(auditService, name, args, () => imapService.bulkUpdateLabels({ emailIds, match, folder, labelsToAdd, labelsToRemove, resolvedUids: uids, dryRun: false }));
+                    const result = await withAudit(auditService, name, args, () => imapService.bulkUpdateLabels({ emailIds, match, folder, labelsToAdd, labelsToRemove, resolvedUids: uids, uidValidity: currentUidValidity, dryRun: false }));
                     return createTextResult(withBulkNotFound(result, notFoundEmailIds));
                 }
                 case "top_senders": {
@@ -4262,20 +4363,27 @@ export function createServer(config, options = {}) {
                     ensureMailboxWriteAllowed(config.runtime);
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args?.confirmed, false), "Permanently delete folder and all messages in it: " + requireString(args, "path"));
                     return createTextResult(await withAudit(auditService, name, args, async () => imapService.deleteFolder(requireString(args, "path"))));
-                case "mark_email_read":
+                case "mark_email_read": {
                     ensureEmailActionAllowed(config.runtime, normalizeBoolean(args.isRead, true) ? "mark_read" : "mark_unread");
-                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.markEmailRead(requireString(args, "emailId"), normalizeBoolean(args.isRead, true))));
-                case "star_email":
+                    const emailId = requireString(args, "emailId");
+                    const uidValidity = parseEmailId(emailId).uidValidity;
+                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.markEmailRead(emailId, normalizeBoolean(args.isRead, true), uidValidity)));
+                }
+                case "star_email": {
                     ensureEmailActionAllowed(config.runtime, normalizeBoolean(args.isStarred, true) ? "star" : "unstar");
-                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.starEmail(requireString(args, "emailId"), normalizeBoolean(args.isStarred, true))));
+                    const emailId = requireString(args, "emailId");
+                    const uidValidity = parseEmailId(emailId).uidValidity;
+                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.starEmail(emailId, normalizeBoolean(args.isStarred, true), uidValidity)));
+                }
                 case "move_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "move");
                         const emailId = requireString(args, "emailId");
                         const targetFolder = requireString(args, "targetFolder");
+                        const uidValidity = parseEmailId(emailId).uidValidity;
                         const result = await withAudit(auditService, name, args, async () => {
                             try {
-                                return await imapService.moveEmail(emailId, targetFolder);
+                                return await imapService.moveEmail(emailId, targetFolder, uidValidity);
                             }
                             catch (error) {
                                 if (isMissingTargetFolderError(error)) {
@@ -4300,7 +4408,9 @@ export function createServer(config, options = {}) {
                 case "archive_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "archive");
-                        const result = await withAudit(auditService, name, args, async () => imapService.archiveEmail(requireString(args, "emailId")));
+                        const emailId = requireString(args, "emailId");
+                        const uidValidity = parseEmailId(emailId).uidValidity;
+                        const result = await withAudit(auditService, name, args, async () => imapService.archiveEmail(emailId, uidValidity));
                         const sources = result.targetEmailId
                             ? [
                                 {
@@ -4317,7 +4427,9 @@ export function createServer(config, options = {}) {
                 case "trash_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "trash");
-                        const result = await withAudit(auditService, name, args, async () => imapService.trashEmail(requireString(args, "emailId")));
+                        const emailId = requireString(args, "emailId");
+                        const uidValidity = parseEmailId(emailId).uidValidity;
+                        const result = await withAudit(auditService, name, args, async () => imapService.trashEmail(emailId, uidValidity));
                         const sources = result.targetEmailId
                             ? [
                                 {
@@ -4334,7 +4446,9 @@ export function createServer(config, options = {}) {
                 case "restore_email":
                     {
                         ensureEmailActionAllowed(config.runtime, "restore");
-                        const result = await withAudit(auditService, name, args, async () => imapService.restoreEmail(requireString(args, "emailId"), optionalString(args, "targetFolder")));
+                        const emailId = requireString(args, "emailId");
+                        const uidValidity = parseEmailId(emailId).uidValidity;
+                        const result = await withAudit(auditService, name, args, async () => imapService.restoreEmail(emailId, optionalString(args, "targetFolder"), uidValidity));
                         const sources = result.targetEmailId
                             ? [
                                 {
@@ -4407,10 +4521,13 @@ export function createServer(config, options = {}) {
                     const result = await withAudit(auditService, name, args, async () => templateService.render(requireString(args, "id"), variables));
                     return createTextResult(result);
                 }
-                case "delete_email":
+                case "delete_email": {
                     ensureDestructiveConfirmed(config.runtime, normalizeBoolean(args.confirmed, false), `Permanently delete ${String(args.emailId ?? "?")} (cannot be recovered)`);
                     ensureMailboxWriteAllowed(config.runtime);
-                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.deleteEmail(requireString(args, "emailId"))));
+                    const emailId = requireString(args, "emailId");
+                    const uidValidity = parseEmailId(emailId).uidValidity;
+                    return createTextResult(await withAudit(auditService, name, args, async () => imapService.deleteEmail(emailId, uidValidity)));
+                }
                 case "batch_email_action":
                     {
                         const emailIds = [...new Set(parseStringListArg(args, "emailIds"))];