@remit/imap-worker 0.0.42 → 0.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/handlers/append-sent-message.test.ts

@@ -3,6 +3,7 @@ import { beforeEach, describe, it } from "node:test";
 import type { Logger } from "@remit/logger-lambda";
 import type { AppendSentMessageEvent } from "../events.js";
 import {
+	APPEND_SENT_MAX_ATTEMPTS,
 	type AppendSentMessageDeps,
 	handleAppendSentMessage,
 } from "./append-sent-message.js";
@@ -31,12 +32,19 @@ interface Harness {
 	};
 	outbox: Record<string, unknown>;
 	specialUseSent: { mailboxId: string; fullPath: string } | null;
-	mailboxes: { mailboxId: string; fullPath: string }[];
+	mailboxes: {
+		mailboxId: string;
+		fullPath: string;
+		hierarchyDelimiter: string;
+	}[];
 	append: (
 		path: string,
 		raw: Buffer,
 		flags: string[],
 	) => Promise<{ uid: number; uidValidity: number }>;
+	/** Stand in for a terminal auth failure: withOAuthLifecycle ACKs the record
+	 * without ever running the work. */
+	ackWithoutWork: boolean;
 	disconnectCount: number;
 }
 
@@ -66,13 +74,18 @@ const fresh = (): Harness => ({
 	},
 	specialUseSent: { mailboxId: "sent-mbx", fullPath: "Sent" },
 	mailboxes: [
-		{ mailboxId: "inbox-mbx", fullPath: "INBOX" },
-		{ mailboxId: "sent-items-mbx", fullPath: "Sent Items" },
+		{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "/" },
+		{
+			mailboxId: "sent-items-mbx",
+			fullPath: "Sent Items",
+			hierarchyDelimiter: "/",
+		},
 	],
 	append: async (path, raw, flags) => {
 		h.calls.push({ method: "connection.append", args: [path, raw, flags] });
 		return { uid: 55, uidValidity: 7 };
 	},
+	ackWithoutWork: false,
 	disconnectCount: 0,
 });
 
@@ -87,6 +100,7 @@ const deps = (): AppendSentMessageDeps =>
 			},
 			outboxMessage: {
 				get: async () => h.outbox,
+				update: record("outboxMessage.update"),
 				delete: record("outboxMessage.delete"),
 			},
 			outboxAttachment: {
@@ -96,7 +110,7 @@ const deps = (): AppendSentMessageDeps =>
 				findBySpecialUse: async () => h.specialUseSent,
 			},
 			mailbox: {
-				listByAccount: async () => ({ items: h.mailboxes }),
+				listAllByAccount: async () => h.mailboxes,
 			},
 			secrets: {},
 		}),
@@ -106,7 +120,7 @@ const deps = (): AppendSentMessageDeps =>
 			_account: unknown,
 			_log: unknown,
 			cb: (credentials: unknown) => Promise<void>,
-		) => cb({}),
+		) => (h.ackWithoutWork ? undefined : cb({})),
 		createConnectionScope: () => ({
 			getConnection: async () => ({
 				append: (path: string, raw: Buffer, flags: string[]) =>
@@ -133,7 +147,7 @@ describe("handleAppendSentMessage", () => {
 	});
 
 	it("appends a seen RFC822 copy to the Sent folder and drops the outbox row", async () => {
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		const append = called("connection.append")[0];
 		assert.equal(append?.args[0], "Sent");
@@ -146,7 +160,7 @@ describe("handleAppendSentMessage", () => {
 	});
 
 	it("takes the draft's stored attachments with the row (#679)", async () => {
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		// The row is the only reference to those objects. Sweeping has to happen
 		// here too, not only on a discard, or a sent message leaves its files
@@ -159,7 +173,7 @@ describe("handleAppendSentMessage", () => {
 	});
 
 	it("builds the message from the outbox row's own headers", async () => {
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		const raw = String(called("connection.append")[0]?.args[1] as Buffer);
 		assert.match(raw, /^From: Alice <alice@example\.com>$/m);
@@ -174,7 +188,7 @@ describe("handleAppendSentMessage", () => {
 	it("uses a bare address when the outbox row carries no display name", async () => {
 		h.outbox = { ...h.outbox, fromName: undefined };
 
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		const raw = String(called("connection.append")[0]?.args[1] as Buffer);
 		assert.match(raw, /^From: alice@example\.com$/m);
@@ -183,25 +197,77 @@ describe("handleAppendSentMessage", () => {
 	it("falls back to a conventionally-named Sent folder when no special-use flag is set", async () => {
 		h.specialUseSent = null;
 
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		assert.equal(called("connection.append")[0]?.args[0], "Sent Items");
 	});
 
-	it("skips the append when the account has no Sent folder at all", async () => {
+	it("files into a Sent folder nested under INBOX when no special-use flag is set", async () => {
 		h.specialUseSent = null;
-		h.mailboxes = [{ mailboxId: "inbox-mbx", fullPath: "INBOX" }];
+		h.mailboxes = [
+			{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "/" },
+			{
+				mailboxId: "sent-mbx",
+				fullPath: "INBOX/Sent",
+				hierarchyDelimiter: "/",
+			},
+			{
+				mailboxId: "sent-messages-mbx",
+				fullPath: "INBOX/Sent Messages",
+				hierarchyDelimiter: "/",
+			},
+		];
+
+		await handleAppendSentMessage(event, noopLog, 1, deps());
+
+		assert.equal(called("connection.append")[0]?.args[0], "INBOX/Sent");
+		assert.deepEqual(called("outboxMessage.delete")[0]?.args, [
+			"cfg-1",
+			"out-1",
+		]);
+	});
+
+	it("files into a nested Sent folder under a non-INBOX prefix and a dot delimiter", async () => {
+		h.specialUseSent = null;
+		h.mailboxes = [
+			{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "." },
+			{
+				mailboxId: "sent-mbx",
+				fullPath: "Mail.Sent Items",
+				hierarchyDelimiter: ".",
+			},
+		];
+
+		await handleAppendSentMessage(event, noopLog, 1, deps());
+
+		assert.equal(called("connection.append")[0]?.args[0], "Mail.Sent Items");
+	});
 
-		await handleAppendSentMessage(event, noopLog, deps());
+	it("settles the row as unfiled when the account has no Sent folder at all", async () => {
+		h.specialUseSent = null;
+		h.mailboxes = [
+			{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "/" },
+		];
+
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		assert.equal(called("connection.append").length, 0);
 		assert.equal(called("outboxMessage.delete").length, 0);
+
+		// The message was delivered over SMTP. Leaving the row at `sent` hides it
+		// from the Outbox list and it exists in no server folder either, so the
+		// user loses it entirely.
+		const update = called("outboxMessage.update")[0];
+		assert.deepEqual(update?.args.slice(0, 2), ["cfg-1", "out-1"]);
+		const patch = update?.args[2] as { status: string; lastError: string };
+		assert.equal(patch.status, "unfiled");
+		assert.match(patch.lastError, /no Sent folder/);
 	});
 
 	it("skips the append while the outbox row is not yet sent", async () => {
 		h.outbox = { ...h.outbox, status: "pending" };
 
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		assert.equal(called("connection.append").length, 0);
 		assert.equal(called("outboxMessage.delete").length, 0);
@@ -210,23 +276,84 @@ describe("handleAppendSentMessage", () => {
 	it("returns early without touching the outbox when the account is soft-deleted", async () => {
 		h.account = { ...h.account, deletedAt: Date.now() };
 
-		await handleAppendSentMessage(event, noopLog, deps());
+		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		assert.equal(called("connection.append").length, 0);
 		assert.equal(called("outboxMessage.delete").length, 0);
 	});
 
-	it("keeps the outbox row when the APPEND fails so the send can be retried", async () => {
+	it("rethrows a failed APPEND while the queue still has attempts left", async () => {
 		h.append = async () => {
 			throw new Error("server exploded");
 		};
 
 		await assert.rejects(
-			handleAppendSentMessage(event, noopLog, deps()),
+			handleAppendSentMessage(event, noopLog, 1, deps()),
 			/server exploded/,
 		);
 
+		// Nothing settled: the row stays `sent` and the redelivered event tries
+		// the APPEND again.
 		assert.equal(called("outboxMessage.delete").length, 0);
+		assert.equal(called("outboxMessage.update").length, 0);
 		assert.equal(h.disconnectCount, 1);
 	});
+
+	it("settles the row as unfiled on the last attempt instead of dead-lettering it", async () => {
+		h.append = async () => {
+			throw new Error("server exploded");
+		};
+
+		await handleAppendSentMessage(
+			event,
+			noopLog,
+			APPEND_SENT_MAX_ATTEMPTS,
+			deps(),
+		);
+
+		// A DLQ'd APPEND is how the message went missing: the row would keep the
+		// `sent` status the Outbox list hides, and no Sent folder holds it.
+		assert.equal(called("outboxMessage.delete").length, 0);
+		const patch = called("outboxMessage.update")[0]?.args[2] as {
+			status: string;
+			lastError: string;
+		};
+		assert.equal(patch.status, "unfiled");
+		assert.match(patch.lastError, /server exploded/);
+	});
+
+	it("settles the row as unfiled when a terminal auth failure acks the record", async () => {
+		h.ackWithoutWork = true;
+
+		await handleAppendSentMessage(event, noopLog, 1, deps());
+
+		const patch = called("outboxMessage.update")[0]?.args[2] as {
+			status: string;
+			lastError: string;
+		};
+		assert.equal(patch.status, "unfiled");
+		assert.match(patch.lastError, /signed in again/);
+	});
+
+	it("leaves the row alone when the APPEND landed but the delete did not", async () => {
+		const failingDeps = deps();
+		const client = await failingDeps.getClient();
+		(
+			client as unknown as { outboxMessage: { delete: () => Promise<void> } }
+		).outboxMessage.delete = async () => {
+			throw new Error("storage down");
+		};
+
+		await assert.rejects(
+			handleAppendSentMessage(event, noopLog, APPEND_SENT_MAX_ATTEMPTS, {
+				...failingDeps,
+				getClient: async () => client,
+			} as AppendSentMessageDeps),
+			/storage down/,
+		);
+
+		// The copy is in Sent, so the message is findable — settling it as unfiled
+		// would say the opposite.
+		assert.equal(called("outboxMessage.update").length, 0);
+	});
 });

package/src/handlers/append-sent-message.ts

@@ -3,7 +3,7 @@ import type {
 	IMailboxRepository,
 	IMailboxSpecialUseRepository,
 } from "@remit/data-ports";
-import { MailboxSpecialUse } from "@remit/domain-enums";
+import { MailboxSpecialUse, OutboxMessageStatus } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 import {
 	buildMailMessage,
@@ -12,6 +12,7 @@ import {
 import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import type { AppendSentMessageEvent } from "../events.js";
+import { resolveSentMailboxByName } from "../sent-mailbox.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 
@@ -28,26 +29,39 @@ const findSentMailbox = async (
 		return bySpecialUse;
 	}
 
-	const commonSentNames = [
-		"Sent",
-		"Sent Items",
-		"Sent Messages",
-		"[Gmail]/Sent Mail",
-	];
-	const mailboxResult = await mailboxService.listByAccount(accountId);
-
-	for (const name of commonSentNames) {
-		const found = mailboxResult.items.find(
-			(m) => m.fullPath.toLowerCase() === name.toLowerCase(),
-		);
-		if (found) {
-			return { mailboxId: found.mailboxId, fullPath: found.fullPath };
-		}
-	}
+	const mailboxes = await mailboxService.listAllByAccount(accountId);
+	return resolveSentMailboxByName(mailboxes);
+};
 
-	return null;
+const UNFILED_NO_SENT_MAILBOX =
+	"Sent, but not filed: this account has no Sent folder. Create one named Sent and later messages will be filed there.";
+
+const UNFILED_SIGNED_OUT =
+	"Sent, but not filed: this account has to be signed in again before a copy can be stored in Sent.";
+
+const unfiledAppendRefused = (fullPath: string, error: unknown): string =>
+	`Sent, but not filed: the mail server refused to store a copy in ${fullPath} (${error instanceof Error ? error.message : String(error)}).`;
+
+/**
+ * Fallback when `APPEND_SENT_MAX_ATTEMPTS` is unset (local dev, unit tests).
+ * Matches the shared `MAX_RECEIVE_COUNT` every queue's redrive policy uses,
+ * same pattern as `FLAG_PUSH_MAX_ATTEMPTS` / `BODY_SYNC_MAX_ATTEMPTS`.
+ */
+const DEFAULT_APPEND_SENT_MAX_ATTEMPTS = 3;
+
+export const getAppendSentMaxAttempts = (
+	processEnv: NodeJS.ProcessEnv = process.env,
+): number => {
+	const raw = processEnv.APPEND_SENT_MAX_ATTEMPTS;
+	if (!raw) return DEFAULT_APPEND_SENT_MAX_ATTEMPTS;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0
+		? parsed
+		: DEFAULT_APPEND_SENT_MAX_ATTEMPTS;
 };
 
+export const APPEND_SENT_MAX_ATTEMPTS = getAppendSentMaxAttempts();
+
 export interface AppendSentMessageDeps {
 	getClient: typeof getClient;
 	buildLifecycleDeps: typeof buildLifecycleDeps;
@@ -65,6 +79,13 @@ const defaultDeps: AppendSentMessageDeps = {
 export const handleAppendSentMessage = async (
 	event: AppendSentMessageEvent,
 	log: Logger,
+	/**
+	 * SQS's own delivery count for this record. The APPEND is the last step of a
+	 * message the user has already had delivered, so exhausting the redrive
+	 * budget must settle the row rather than dead-letter it: a DLQ'd record
+	 * leaves the row at `sent`, which no view shows.
+	 */
+	receiveCount = 1,
 	deps: AppendSentMessageDeps = defaultDeps,
 ): Promise<void> => {
 	const {
@@ -96,7 +117,7 @@ export const handleAppendSentMessage = async (
 		account.accountConfigId,
 		outboxMessageId,
 	);
-	if (outbox.status !== "sent") {
+	if (outbox.status !== OutboxMessageStatus.sent) {
 		log.info(
 			{ outboxMessageId, status: outbox.status },
 			"Outbox message not in sent status, skipping APPEND",
@@ -104,17 +125,38 @@ export const handleAppendSentMessage = async (
 		return;
 	}
 
+	// The message left over SMTP; only the filing can still fail. Settling the
+	// row as `unfiled` keeps it in the Outbox list rather than deleting it, so a
+	// delivered message stays readable somewhere. Every path out of this handler
+	// that is not a confirmed APPEND ends here.
+	const settleUnfiled = async (reason: string): Promise<void> => {
+		log.error(
+			{ accountId, outboxMessageId, reason },
+			"Sent message could not be filed, settling the outbox row as unfiled",
+		);
+		await outboxMessageService.update(
+			account.accountConfigId,
+			outboxMessageId,
+			{
+				status: OutboxMessageStatus.unfiled,
+				lastError: reason,
+			},
+		);
+	};
+
 	const sentMailbox = await findSentMailbox(
 		mailboxSpecialUseService,
 		mailboxService,
 		accountId,
 	);
 	if (!sentMailbox) {
-		log.info({ accountId }, "No Sent mailbox found, skipping IMAP APPEND");
+		await settleUnfiled(UNFILED_NO_SENT_MAILBOX);
 		return;
 	}
 
-	await withOAuthLifecycle(
+	let appended = false;
+
+	const failure = await withOAuthLifecycle(
 		buildLifecycleDeps(secrets, accountService),
 		account,
 		log,
@@ -141,6 +183,8 @@ export const handleAppendSentMessage = async (
 						},
 						"Appended sent message to Sent mailbox",
 					);
+
+					appended = true;
 				})
 				.finally(() => scope.disconnect());
 
@@ -168,5 +212,31 @@ export const handleAppendSentMessage = async (
 				"Deleted outbox row after successful APPEND to Sent",
 			);
 		},
+	).then(
+		() => null,
+		(error: unknown) => {
+			// Below the redrive budget this is an ordinary retry — connections
+			// drop, servers go away, and the row is still `sent` for the next
+			// attempt to pick up. At the budget the record would dead-letter, and a
+			// dead-lettered APPEND is exactly how a delivered message goes missing.
+			//
+			// Once the APPEND itself has landed the copy is in Sent whatever else
+			// failed, so that case keeps the plain retry semantics.
+			if (appended || receiveCount < APPEND_SENT_MAX_ATTEMPTS) throw error;
+			return error;
+		},
+	);
+
+	// The APPEND landed: the copy is in Sent even if the row delete that follows
+	// it failed, so there is nothing to settle and a retry may still run.
+	if (appended) return;
+
+	// A terminal auth failure returns here without throwing — withOAuthLifecycle
+	// flips the account to reauth_required and ACKs the record, which without
+	// this would leave the row at `sent` and the message nowhere.
+	await settleUnfiled(
+		failure
+			? unfiledAppendRefused(sentMailbox.fullPath, failure)
+			: UNFILED_SIGNED_OUT,
 	);
 };

package/src/processor.ts

@@ -18,8 +18,9 @@ export const processEvent = async (
 	log: Logger,
 	/**
 	 * SQS's own delivery count for the record carrying this event (1 on first
-	 * delivery). Read by SYNC_MESSAGE_BODY, PLACEMENT_MOVE_PUSH and FLAG_PUSH
-	 * — each knows from it when this is the last attempt before the queue's
+	 * delivery). Read by SYNC_MESSAGE_BODY, PLACEMENT_MOVE_PUSH, FLAG_PUSH and
+	 * APPEND_SENT_MESSAGE — each knows from it when this is the last attempt
+	 * before the queue's
 	 * own redrive policy would DLQ the record, so it can resolve
 	 * retry exhaustion into a terminal outcome (issue #1270) instead of
 	 * dead-lettering blindly.
@@ -50,7 +51,7 @@ export const processEvent = async (
 		case "EMPTY_TRASH":
 			return handleEmptyTrash(event, log);
 		case "APPEND_SENT_MESSAGE":
-			return handleAppendSentMessage(event, log);
+			return handleAppendSentMessage(event, log, receiveCount);
 		case "DELETE_ACCOUNT_OBJECTS":
 			return handleDeleteAccountObjects(event, log);
 		case "IMAP_WORKER_STOP":

package/src/sent-mailbox.test.ts

@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	resolveSentMailboxByName,
+	type SentMailboxCandidate,
+} from "./sent-mailbox.js";
+
+const mailbox = (
+	fullPath: string,
+	hierarchyDelimiter = "/",
+): SentMailboxCandidate => ({
+	mailboxId: `mbx-${fullPath}`,
+	fullPath,
+	hierarchyDelimiter,
+});
+
+describe("resolveSentMailboxByName", () => {
+	it("finds a top-level Sent folder", () => {
+		const found = resolveSentMailboxByName([mailbox("INBOX"), mailbox("Sent")]);
+
+		assert.equal(found?.fullPath, "Sent");
+	});
+
+	it("finds a Sent folder nested under INBOX", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX"),
+			mailbox("INBOX/Archive"),
+			mailbox("INBOX/Sent"),
+		]);
+
+		assert.equal(found?.fullPath, "INBOX/Sent");
+	});
+
+	it("finds a nested Sent folder under a non-INBOX prefix with a non-slash delimiter", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("Mail.Drafts", "."),
+			mailbox("Mail.Sent Items", "."),
+		]);
+
+		assert.equal(found?.fullPath, "Mail.Sent Items");
+	});
+
+	it("finds the Gmail Sent folder by its leaf name", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX"),
+			mailbox("[Gmail]/All Mail"),
+			mailbox("[Gmail]/Sent Mail"),
+		]);
+
+		assert.equal(found?.fullPath, "[Gmail]/Sent Mail");
+	});
+
+	it("prefers the shallowest folder when several leaves match", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX/Clients/Sent"),
+			mailbox("INBOX/Sent"),
+		]);
+
+		assert.equal(found?.fullPath, "INBOX/Sent");
+	});
+
+	it("prefers the plain Sent name over the longer variants", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX/Sent Messages"),
+			mailbox("INBOX/Sent"),
+		]);
+
+		assert.equal(found?.fullPath, "INBOX/Sent");
+	});
+
+	it("matches the leaf regardless of case", () => {
+		const found = resolveSentMailboxByName([mailbox("INBOX.sent items", ".")]);
+
+		assert.equal(found?.fullPath, "INBOX.sent items");
+	});
+
+	it("does not match a folder that merely starts with a Sent name", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX/Sent Archive 2024"),
+			mailbox("INBOX/Sentinel"),
+		]);
+
+		assert.equal(found, null);
+	});
+
+	it("prefers a shallower Sent over a deeper better-named one", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX.Sent Items", "."),
+			mailbox("INBOX.Trash.Sent", "."),
+		]);
+
+		assert.equal(found?.fullPath, "INBOX.Sent Items");
+	});
+
+	it("resolves a flat namespace that reports no delimiter at all", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX", ""),
+			mailbox("Sent", ""),
+		]);
+
+		assert.equal(found?.fullPath, "Sent");
+	});
+
+	it("returns null when the account has no Sent folder", () => {
+		const found = resolveSentMailboxByName([
+			mailbox("INBOX"),
+			mailbox("INBOX/Trash"),
+		]);
+
+		assert.equal(found, null);
+	});
+});

package/src/sent-mailbox.ts

@@ -0,0 +1,20 @@
+import type { MailboxItem } from "@remit/data-ports";
+import { resolveMailboxByLeafName } from "@remit/data-ports/mailbox-name";
+
+export type SentMailboxCandidate = Pick<
+	MailboxItem,
+	"mailboxId" | "fullPath" | "hierarchyDelimiter"
+>;
+
+const SENT_FOLDER_NAMES = ["sent", "sent items", "sent messages", "sent mail"];
+
+/**
+ * The Sent folder by conventional name, for servers that advertise no `\Sent`
+ * special-use. Matches the folder's own leaf segment, so it resolves at any
+ * depth under any prefix (`INBOX/Sent`, `Mail.Sent Items`, `[Gmail]/Sent Mail`)
+ * without knowing which prefixes a server uses.
+ */
+export const resolveSentMailboxByName = (
+	mailboxes: SentMailboxCandidate[],
+): SentMailboxCandidate | null =>
+	resolveMailboxByLeafName(mailboxes, SENT_FOLDER_NAMES);