@remit/mailbox-service 0.0.110 → 0.0.112

package/src/imapflow-connect-retry.test.ts

@@ -1,134 +1,97 @@
-/**
- * Unit tests for ImapFlowConnection.connect() retry semantics.
- *
- * Verifies the retry policy without touching a real IMAP server:
- * - Network errors (e.g. ECONNREFUSED) are retried with backoff before the
- *   classified MailConnectionError("network") is finally thrown.
- * - Auth errors are thrown immediately and NEVER retried.
- *
- * The private `attemptConnect` and `sleep` instance methods are stubbed so the
- * test exercises the loop logic directly and runs instantly.
- */
-
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
+import { createServer, type Server, type Socket } from "node:net";
+import { after, describe, it } from "node:test";
 import { ImapFlowConnection } from "./imapflow-connection.js";
 import { MailConnectionError } from "./types.js";
 
-const baseConfig = {
-	host: "localhost",
-	port: 143,
-	user: "alice@example.com",
-	credentials: { kind: "password" as const, password: "s3cr3t" },
-	tls: false,
-};
-
-type WithPrivates = {
-	attemptConnect: () => Promise<void>;
-	sleep: (ms: number) => Promise<void>;
-};
-
-const makeErrnoError = (code: string): Error => {
-	const err = new Error(`connect ${code}`);
-	return Object.assign(err, { code });
-};
+const servers: Server[] = [];
+const sockets: Socket[] = [];
 
-describe("ImapFlowConnection.connect() retry policy", () => {
-	it("retries network errors (ECONNREFUSED) 3x with backoff, then throws classified network error", async () => {
-		const connection = new ImapFlowConnection(baseConfig);
-		const priv = connection as unknown as WithPrivates;
+after(() => {
+	for (const socket of sockets) socket.destroy();
+	for (const server of servers) server.close();
+});
 
-		// Always fail with a network-level error.
-		const attempt = mock.method(priv, "attemptConnect", async () => {
-			throw makeErrnoError("ECONNREFUSED");
+const listen = (server: Server): Promise<number> =>
+	new Promise((resolve) => {
+		servers.push(server);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			resolve(typeof address === "object" && address ? address.port : 0);
 		});
-		// Stub sleep so the backoff does not actually delay the test.
-		mock.method(priv, "sleep", async () => {});
-
-		await assert.rejects(
-			() => connection.connect(),
-			(error: unknown) => {
-				assert.ok(
-					error instanceof MailConnectionError,
-					"final error should be a MailConnectionError",
-				);
-				assert.equal(error.kind, "network");
-				// The host:port endpoint must appear in the message so a DNS /
-				// connect failure is self-describing in the logs (issue #835).
-				assert.match(error.message, /localhost:143/);
-				return true;
-			},
-		);
-
-		// 3 attempts total (the retry loop runs maxRetries times).
-		assert.equal(attempt.mock.callCount(), 3);
 	});
 
-	it("succeeds on a later attempt when a transient network error clears", async () => {
-		const connection = new ImapFlowConnection(baseConfig);
-		const priv = connection as unknown as WithPrivates;
-
-		let calls = 0;
-		const attempt = mock.method(priv, "attemptConnect", async () => {
-			calls += 1;
-			if (calls < 2) {
-				throw makeErrnoError("ECONNRESET");
+const refusingLogin = async (refusal: string) => {
+	const state = { connections: 0 };
+	const server = createServer((socket) => {
+		state.connections++;
+		sockets.push(socket);
+		socket.write("* OK [CAPABILITY IMAP4rev1] ready\r\n");
+		let buffered = "";
+		socket.on("data", (chunk) => {
+			buffered += chunk.toString();
+			let end = buffered.indexOf("\r\n");
+			while (end !== -1) {
+				const line = buffered.slice(0, end);
+				buffered = buffered.slice(end + 2);
+				const [tag, command] = line.split(" ");
+				const verb = command?.toUpperCase();
+				if (verb === "CAPABILITY") {
+					socket.write(`* CAPABILITY IMAP4rev1\r\n${tag} OK done\r\n`);
+				} else if (verb === "LOGIN") {
+					socket.write(`${tag} NO [AUTHENTICATIONFAILED] ${refusal}\r\n`);
+				} else if (verb === "LOGOUT") {
+					socket.end(`* BYE\r\n${tag} OK bye\r\n`);
+				} else {
+					socket.write(`${tag} BAD unknown\r\n`);
+				}
+				end = buffered.indexOf("\r\n");
 			}
-			// Second attempt succeeds.
 		});
-		mock.method(priv, "sleep", async () => {});
-
-		await connection.connect();
-
-		assert.equal(attempt.mock.callCount(), 2);
+		socket.on("error", () => {});
 	});
+	return { port: await listen(server), state };
+};
 
-	it("does NOT retry auth errors — throws immediately on attempt 1", async () => {
-		const connection = new ImapFlowConnection(baseConfig);
-		const priv = connection as unknown as WithPrivates;
-
-		const attempt = mock.method(priv, "attemptConnect", async () => {
-			throw new Error("Invalid credentials");
-		});
-		const sleep = mock.method(priv, "sleep", async () => {});
+const closedPort = async (): Promise<number> => {
+	const server = createServer();
+	const port = await listen(server);
+	await new Promise((resolve) => server.close(resolve));
+	return port;
+};
 
-		await assert.rejects(
-			() => connection.connect(),
-			(error: unknown) => {
-				assert.ok(error instanceof MailConnectionError);
-				assert.equal(error.kind, "auth");
-				return true;
-			},
-		);
+const connectTo = (port: number) =>
+	new ImapFlowConnection({
+		host: "127.0.0.1",
+		port,
+		user: "alice@example.com",
+		credentials: { kind: "password", password: "s3cr3t" },
+		tls: false,
+	}).connect();
 
-		// Only one attempt, no backoff sleep.
-		assert.equal(attempt.mock.callCount(), 1);
-		assert.equal(sleep.mock.callCount(), 0);
+describe("ImapFlowConnection.connect() retry policy", () => {
+	it("retries a refused connection, then names the endpoint in a network error", async () => {
+		const port = await closedPort();
+
+		await assert.rejects(connectTo(port), (error: unknown) => {
+			assert.ok(error instanceof MailConnectionError);
+			assert.equal(error.kind, "network");
+			assert.match(error.message, new RegExp(`127\\.0\\.0\\.1:${port}`));
+			return true;
+		});
 	});
 
-	it("carries the server's own refusal, which is not always a re-auth", async () => {
-		const connection = new ImapFlowConnection(baseConfig);
-		const priv = connection as unknown as WithPrivates;
+	it("does not retry a refused login and carries the server's own words", async () => {
+		const { port, state } = await refusingLogin(
+			"LOGIN failed. SmtpClientAuthentication is disabled for the Tenant.",
+		);
 
-		// imapflow's shape for a tagged NO: the message is its own, the server's
-		// words are on `responseText`. Signing in again fixes nothing here — the
-		// tenant has IMAP switched off — so the text has to reach the user.
-		mock.method(priv, "attemptConnect", async () => {
-			throw Object.assign(new Error("Command failed"), {
-				authenticationFailed: true,
-				responseText:
-					"LOGIN failed. User is authenticated but not connected. SmtpClientAuthentication is disabled for the Tenant.",
-			});
+		await assert.rejects(connectTo(port), (error: unknown) => {
+			assert.ok(error instanceof MailConnectionError);
+			assert.equal(error.kind, "auth");
+			assert.match(error.message, /SmtpClientAuthentication is disabled/);
+			return true;
 		});
-
-		await assert.rejects(
-			() => connection.connect(),
-			(error: unknown) => {
-				assert.ok(error instanceof MailConnectionError);
-				assert.equal(error.kind, "auth");
-				assert.match(error.message, /SmtpClientAuthentication is disabled/);
-				return true;
-			},
-		);
+		assert.equal(state.connections, 1);
 	});
 });

package/src/imapflow-connection.test.ts

@@ -467,3 +467,37 @@ describe("ImapFlowConnection message envelopes (issue #72)", () => {
 		assert.equal(message?.envelope?.from[0]?.mailbox, "sender");
 	});
 });
+
+describe("ImapFlowConnection.fetchMessageBodies — a body the server no longer has", () => {
+	const fetchBodies = async (
+		rows: Array<Record<string, unknown>>,
+	): Promise<number[]> => {
+		const connection = buildConnectionWithClient({
+			mailbox: fakeMailbox("INBOX", 1),
+			mailboxOpen: async (path: string) => fakeMailbox(path, 1),
+			fetch: () =>
+				(async function* () {
+					for (const row of rows) yield row;
+				})(),
+		});
+		Object.assign(connection as unknown as Record<string, unknown>, {
+			currentMailbox: "INBOX",
+		});
+		const uids: number[] = [];
+		for await (const { uid, source } of connection.fetchMessageBodies([1, 2])) {
+			source.resume();
+			uids.push(uid);
+		}
+		return uids;
+	};
+
+	it("leaves out a row whose source is false instead of failing the batch", async () => {
+		assert.deepStrictEqual(
+			await fetchBodies([
+				{ uid: 1, source: false },
+				{ uid: 2, source: Buffer.from("Subject: x\r\n\r\nhi") },
+			]),
+			[2],
+		);
+	});
+});

package/src/imapflow-connection.ts

@@ -721,9 +721,9 @@ export class ImapFlowConnection {
 	 * Fetch the full message body (RFC822 source) for a single message by UID.
 	 *
 	 * @param uid - The UID of the message to fetch
-	 * @returns The raw message body as a Buffer
+	 * @returns The raw message body, or null when the UID FETCH matched no message
 	 */
-	fetchMessageBody = async (uid: number): Promise<Buffer> => {
+	fetchMessageBody = async (uid: number): Promise<Buffer | null> => {
 		this.ensureConnected();
 		const { client } = this;
 
@@ -739,19 +739,22 @@ export class ImapFlowConnection {
 			uid: true,
 		});
 
-		// Connection may have been lost during download
-		if (!result || !result.content) {
-			throw new Error(
-				`IMAP connection lost while downloading message UID ${uid}`,
-			);
+		if (result?.content) {
+			const chunks: Buffer[] = [];
+			for await (const chunk of result.content) {
+				chunks.push(chunk);
+			}
+			return Buffer.concat(chunks);
 		}
 
-		const chunks: Buffer[] = [];
-		for await (const chunk of result.content) {
-			chunks.push(chunk);
+		if (!client.usable || !client.mailbox) {
+			throw new MailConnectionError(
+				"network",
+				`IMAP connection lost while downloading message UID ${uid}`,
+			);
 		}
 
-		return Buffer.concat(chunks);
+		return null;
 	};
 
 	/**
@@ -802,10 +805,11 @@ export class ImapFlowConnection {
 		try {
 			for await (const msg of fetchIterator) {
 				// imapflow can yield a row with an undefined uid or no source on
-				// back-to-back FETCH calls; skip it rather than crash the batch — the
-				// caller treats any UID it never sees as failed and re-enqueues it.
-				// See #408.
-				if (msg.uid == null || msg.source == null) {
+				// back-to-back FETCH calls, and Dovecot answers `source: false` for a
+				// message another client expunged; skip it rather than crash the batch
+				// — the caller treats any UID it never sees as failed and re-enqueues
+				// it. See #408.
+				if (msg.uid == null || !msg.source) {
 					continue;
 				}
 

package/src/index.ts

@@ -27,6 +27,7 @@ export {
 export {
 	type BodySyncFolder,
 	type BodySyncLogger,
+	type BodySyncRoundFolder,
 	BodySyncService,
 	type ConnectionGetter,
 	extractSnippet,
@@ -81,16 +82,18 @@ export {
 	testSmtpConnection,
 } from "./connection-test.js";
 export {
-	type AnchorDriftDeps,
-	type AnchorEmbedder,
-	refreshAnchorForEmbedder,
-} from "./filters/anchor-drift.js";
+	type CreatedFilter,
+	createFilter,
+	type FilterPage,
+	type FilterPatch,
+	listFilters,
+	type NewFilter,
+	resolveFilterUpdate,
+	updateFilter,
+} from "./filter-operations.js";
 export { extractListId, normalizeListId } from "./filters/list-id.js";
 export {
-	buildMatchText,
 	clauseMatches,
-	cosineSimilarity,
-	DEFAULT_SEMANTIC_MATCH_THRESHOLD,
 	type FilterMessage,
 	type LiteralClauseNarrowing,
 	literalClausesMatch,
@@ -103,7 +106,6 @@ export {
 	type FilterDecision,
 	type FilterLogger,
 	FilterPipeline,
-	type MessageEmbedder,
 } from "./filters/pipeline.js";
 export {
 	type FlagPushConfig,
@@ -126,6 +128,17 @@ export {
 	type UpdateFlagsInput,
 	type UpdateFlagsResult,
 } from "./flag-queue.js";
+export {
+	type CreateFolderDeps,
+	changeFolderPath,
+	createFolder,
+	type FolderPathChange,
+	type FolderPathDeps,
+	type FolderPathOutcome,
+	type NewFolder,
+	type NewFolderOutcome,
+	ownedFolder,
+} from "./folder-operations.js";
 export {
 	type FolderPlacementLookup,
 	resolveAccountFolderPlacements,
@@ -188,6 +201,7 @@ export {
 	type CursorRebuildSnapshot,
 	matchCursorRebuild,
 } from "./mailbox-cursor-rebuild.js";
+export { folderInFlight } from "./mailbox-intent.js";
 export {
 	type CreateMailboxInput,
 	type DeleteMailboxInput,
@@ -244,12 +258,27 @@ export {
 	parseMessageContent,
 } from "./message-parser.js";
 export { isMessageGoneFromOpenMailbox } from "./message-presence.js";
+export {
+	type BodyPartMaterializer,
+	type BodySyncCue,
+	type MaterializeLogger,
+	type MaterializeResult,
+	materializeBodyParts,
+} from "./message-read.js";
 export {
 	type ImapConnectionFactory,
 	MessageSyncService,
 	type SyncedMessage,
 	type SyncMessagesResult,
 } from "./message-sync.js";
+export {
+	type OrganizeJobDeps,
+	type OrganizeJobLogger,
+	type OrganizeJobOwner,
+	type OrganizeJobPredicate,
+	type OrganizeJobRequest,
+	queueOrganizeJob,
+} from "./organize-job.js";
 export {
 	type CompleteOutboxAttachmentInput,
 	type CompleteOutboxAttachmentOutcome,
@@ -275,6 +304,13 @@ export {
 	OutboxQueueService,
 	type UpdateDraftInput,
 } from "./outbox-queue.js";
+export {
+	folderInAccount,
+	type MessageOwnershipClient,
+	ownedAccount,
+	ownedMessages,
+	settledFolder,
+} from "./ownership.js";
 export {
 	type PlacementMoveConfig,
 	type PlacementMoveLogger,
@@ -293,6 +329,7 @@ export {
 	isPlacementUnsettled,
 	type PlacementBinding,
 	placementBindingOf,
+	uidMailboxIdOf,
 } from "./placement-settled.js";
 export {
 	type QuarantineContext,
@@ -304,6 +341,15 @@ export {
 	resolveMailboxRole,
 	shapeFromMessageData,
 } from "./quarantine.js";
+export {
+	type AccessMode,
+	accept,
+	invalid,
+	type Refusable,
+	type Refusal,
+	type Refused,
+	refuse,
+} from "./refusal.js";
 export {
 	type RestoreSourcePlacementDeps,
 	type RestoreSourcePlacementInput,
@@ -325,10 +371,11 @@ export {
 	SpamReportService,
 } from "./spam-report.js";
 export {
-	reconcileStaleMessage,
-	type StaleMessageReconcileDeps,
-	type StaleMessageReconcileResult,
-} from "./stale-message-reconcile.js";
+	type ServerUids,
+	type SyncWarningContext,
+	type SyncWarningRound,
+	SyncWarningService,
+} from "./sync-warning.js";
 export {
 	buildThreadMessageMoveRevert,
 	buildThreadMessageTrashUpdate,