@remit/mailbox-service 0.0.114 → 0.0.116

package/dist/connection-factory.d.ts

@@ -3,52 +3,26 @@
  *
  * Uses ImapFlow for all IMAP connections.
  */
-import type { IImapConnection, ImapConnectionConfig, MailCredentials } from "./types.js";
+import type { IImapConnection, ImapConnectionConfig, ImapTransport, MailCredentials } from "./types.js";
 /**
  * Create an IMAP connection
  */
 export declare const createConnection: (config: ImapConnectionConfig) => IImapConnection;
-/**
- * Create an IMAP connection from account data using password credentials.
- */
-export declare const createConnectionFromAccount: (account: {
-    imapHost: string;
-    imapPort: number;
-    imapTls: boolean;
-    username: string;
-}, password: string) => IImapConnection;
 /**
  * Create an IMAP connection from account data using a MailCredentials union.
- * Use this instead of createConnectionFromAccount for OAuth accounts.
  */
 export declare const createConnectionWithCredentials: (account: {
     imapHost: string;
     imapPort: number;
     imapTls: boolean;
     username: string;
-}, credentials: MailCredentials) => IImapConnection;
-/**
- * Managed connection factory that caches and reuses a single connection.
- *
- * The factory handles connection lifecycle - callers should not disconnect.
- * Call close() on the factory to disconnect when done.
- */
-export interface ManagedConnectionFactory {
-    /** Get the cached connection (creates on first call) */
-    getConnection(): IImapConnection;
-    /** Disconnect and cleanup */
-    close(): Promise<void>;
+}, credentials: MailCredentials, transport: ImapTransport) => IImapConnection;
+export interface ConnectionScope {
+    getConnection: () => Promise<IImapConnection>;
+    disconnect: () => Promise<void>;
 }
 /**
- * Create a managed connection factory that caches a single connection.
- *
- * @example
- * ```typescript
- * const factory = createManagedConnectionFactory(config);
- * const conn = factory.getConnection();
- * await conn.connect();
- * // ... reuse conn via factory.getConnection() ...
- * await factory.close(); // Disconnect when done
- * ```
+ * A lazily-connected, cached connection shared across the operations of one
+ * unit of work. Call disconnect() when done.
  */
-export declare const createManagedConnectionFactory: (config: ImapConnectionConfig) => ManagedConnectionFactory;
+export declare const connectionScope: (config: ImapConnectionConfig) => ConnectionScope;

package/dist/connection-factory.js

@@ -3,52 +3,46 @@
  *
  * Uses ImapFlow for all IMAP connections.
  */
-import { createImapFlowConnectionFromAccount, createImapFlowConnectionWithCredentials, ImapFlowConnection, } from "./imapflow-connection.js";
+import { ImapFlowConnection } from "./imapflow-connection.js";
 /**
  * Create an IMAP connection
  */
 export const createConnection = (config) => {
     return new ImapFlowConnection(config);
 };
-/**
- * Create an IMAP connection from account data using password credentials.
- */
-export const createConnectionFromAccount = (account, password) => {
-    return createImapFlowConnectionFromAccount(account, password);
-};
 /**
  * Create an IMAP connection from account data using a MailCredentials union.
- * Use this instead of createConnectionFromAccount for OAuth accounts.
  */
-export const createConnectionWithCredentials = (account, credentials) => {
-    return createImapFlowConnectionWithCredentials(account, credentials);
-};
+export const createConnectionWithCredentials = (account, credentials, transport) => new ImapFlowConnection({
+    host: account.imapHost,
+    port: account.imapPort,
+    tls: account.imapTls,
+    transport,
+    user: account.username,
+    credentials,
+});
 /**
- * Create a managed connection factory that caches a single connection.
- *
- * @example
- * ```typescript
- * const factory = createManagedConnectionFactory(config);
- * const conn = factory.getConnection();
- * await conn.connect();
- * // ... reuse conn via factory.getConnection() ...
- * await factory.close(); // Disconnect when done
- * ```
+ * A lazily-connected, cached connection shared across the operations of one
+ * unit of work. Call disconnect() when done.
  */
-export const createManagedConnectionFactory = (config) => {
+export const connectionScope = (config) => {
     let connection = null;
-    return {
-        getConnection: () => {
-            if (!connection) {
-                connection = new ImapFlowConnection(config);
-            }
-            return connection;
-        },
-        close: async () => {
-            if (connection) {
-                await connection.disconnect();
-                connection = null;
-            }
-        },
+    let connectPromise = null;
+    const getConnection = async () => {
+        if (connectPromise) {
+            return connectPromise;
+        }
+        const conn = createConnection(config);
+        connection = conn;
+        connectPromise = conn.connect().then(() => conn);
+        return connectPromise;
+    };
+    const disconnect = async () => {
+        if (connection) {
+            await connection.disconnect();
+            connection = null;
+            connectPromise = null;
+        }
     };
+    return { getConnection, disconnect };
 };

package/dist/connection-test.d.ts

@@ -1,41 +1,10 @@
-/**
- * Connection testing utilities for IMAP and SMTP servers
- *
- * Used to validate credentials before saving account configuration.
- */
-import type { MailCredentials } from "./types.js";
-export interface TestResult {
-    success: boolean;
-    error?: string;
-}
+import type { TestResult } from "@remit/data-ports";
+import type { ImapTransport, MailCredentials } from "./types.js";
 export interface ImapTestConfig {
-    host: string;
-    port: number;
-    secure: boolean;
-    startTls?: boolean;
-    credentials: MailCredentials;
-    user: string;
-}
-export interface SmtpTestConfig {
     host: string;
     port: number;
     secure: boolean;
     credentials: MailCredentials;
     user: string;
 }
-/**
- * Test IMAP connection with provided credentials.
- *
- * Uses a raw socket to send AUTH PLAIN directly — bypasses the CAPABILITY
- * round-trip that IMAP clients typically perform first, avoiding deadlocks
- * with servers that pipeline their tagged responses.
- *
- * Supports plaintext, direct TLS (secure: true), and STARTTLS (startTls: true).
- */
-export declare const testImapConnection: (config: ImapTestConfig) => Promise<TestResult>;
-/**
- * Test SMTP connection with provided credentials
- *
- * Uses nodemailer's verify() method to test authentication.
- */
-export declare const testSmtpConnection: (config: SmtpTestConfig) => Promise<TestResult>;
+export declare const testImapConnection: (config: ImapTestConfig, transport: ImapTransport) => Promise<TestResult>;

package/dist/connection-test.js

@@ -1,152 +1,19 @@
-/**
- * Connection testing utilities for IMAP and SMTP servers
- *
- * Used to validate credentials before saving account configuration.
- */
-import { createConnection as createNetConnection } from "node:net";
-import { connect as tlsConnect } from "node:tls";
-import { createTransport } from "nodemailer";
-import { MailConnectionError } from "./types.js";
-// TODO(#468): Wire OAuth testConnection once authType/oauthRefreshTokenHash are
-// available on Account. For OAuth accounts, mint a token via MailOAuthService
-// before calling testImapConnection / testSmtpConnection, and map
-// RefreshTokenError(reauth-required) to MailConnectionError("auth", ...).
+import { ImapFlowConnection } from "./imapflow-connection.js";
 const TEST_TIMEOUT_MS = 12_000;
-/**
- * Build nodemailer auth object from credentials.
- */
-const buildSmtpAuth = (user, credentials) => {
-    if (credentials.kind === "password") {
-        return { user, pass: credentials.password };
-    }
-    return {
-        type: "OAuth2",
-        user,
-        accessToken: credentials.accessToken,
-    };
-};
-/**
- * Test IMAP connection with provided credentials.
- *
- * Uses a raw socket to send AUTH PLAIN directly — bypasses the CAPABILITY
- * round-trip that IMAP clients typically perform first, avoiding deadlocks
- * with servers that pipeline their tagged responses.
- *
- * Supports plaintext, direct TLS (secure: true), and STARTTLS (startTls: true).
- */
-export const testImapConnection = async (config) => {
-    if (config.credentials.kind !== "password") {
-        return { success: false, error: "OAuth not supported for connection test" };
-    }
-    const { user, credentials } = config;
-    const authPlain = Buffer.from(`\x00${user}\x00${credentials.password}`).toString("base64");
-    return new Promise((resolve) => {
-        let settled = false;
-        const done = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutId);
-            resolve(result);
-        };
-        const timeoutId = setTimeout(() => done({ success: false, error: "Connection timed out" }), TEST_TIMEOUT_MS);
-        let buf = "";
-        let phase = "greeting";
-        // biome-ignore lint/suspicious/noExplicitAny: socket type varies between net.Socket and tls.TLSSocket
-        let sock;
-        const onData = (chunk) => {
-            buf += chunk.toString();
-            const lines = buf.split("\r\n");
-            buf = lines.pop() ?? "";
-            for (const line of lines) {
-                if (phase === "greeting" && /^\* OK/i.test(line)) {
-                    if (config.startTls) {
-                        phase = "starttls";
-                        sock.write("A001 STARTTLS\r\n");
-                    }
-                    else {
-                        phase = "auth";
-                        sock.write(`A001 AUTHENTICATE PLAIN ${authPlain}\r\n`);
-                    }
-                }
-                else if (phase === "starttls" && /^A001 OK/i.test(line)) {
-                    phase = "tls-upgrade";
-                    // Upgrade socket to TLS in place
-                    const tlsSock = tlsConnect({
-                        socket: sock,
-                        host: config.host,
-                        rejectUnauthorized: false,
-                    });
-                    tlsSock.on("data", onData);
-                    tlsSock.on("error", onError);
-                    tlsSock.once("secureConnect", () => {
-                        phase = "auth";
-                        sock = tlsSock;
-                        sock.write(`A002 AUTHENTICATE PLAIN ${authPlain}\r\n`);
-                    });
-                }
-                else if (phase === "auth" &&
-                    (/^A00[12] OK/i.test(line) || /^A001 OK/i.test(line))) {
-                    phase = "done";
-                    sock.write("A099 LOGOUT\r\n");
-                    done({ success: true });
-                }
-                else if (phase === "auth" &&
-                    (/^A00[12] NO/i.test(line) || /^A00[12] BAD/i.test(line))) {
-                    phase = "done";
-                    sock.destroy();
-                    done({ success: false, error: "Authentication failed" });
-                }
-            }
-        };
-        const onError = (err) => {
-            done({ success: false, error: err.message });
-        };
-        if (config.secure) {
-            sock = tlsConnect({
-                host: config.host,
-                port: config.port,
-                rejectUnauthorized: false,
-            });
-        }
-        else {
-            sock = createNetConnection({ host: config.host, port: config.port });
-        }
-        sock.on("data", onData);
-        sock.on("error", onError);
-    });
-};
-/**
- * Test SMTP connection with provided credentials
- *
- * Uses nodemailer's verify() method to test authentication.
- */
-export const testSmtpConnection = async (config) => {
-    const transport = createTransport({
+export const testImapConnection = async (config, transport) => {
+    const connection = new ImapFlowConnection({
         host: config.host,
         port: config.port,
-        secure: config.secure,
-        auth: buildSmtpAuth(config.user, config.credentials),
-        connectionTimeout: TEST_TIMEOUT_MS,
-        greetingTimeout: TEST_TIMEOUT_MS,
-        socketTimeout: TEST_TIMEOUT_MS,
+        tls: config.secure,
+        user: config.user,
+        credentials: config.credentials,
+        transport,
+        connTimeout: TEST_TIMEOUT_MS,
     });
-    const attempt = transport
-        .verify()
-        .then(() => ({ success: true }))
-        .catch((error) => {
-        if (error instanceof MailConnectionError) {
-            return { success: false, error: error.message };
-        }
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : "Connection failed",
-        };
-    })
-        .finally(() => transport.close());
-    const timeout = new Promise((resolve) => setTimeout(() => {
-        transport.close();
-        resolve({ success: false, error: "Connection timed out" });
-    }, TEST_TIMEOUT_MS));
-    return Promise.race([attempt, timeout]);
+    const result = await connection.connectOnce().then(() => ({ success: true }), (error) => ({
+        success: false,
+        error: error instanceof Error ? error.message : "Connection failed",
+    }));
+    await connection.disconnect();
+    return result;
 };

package/dist/imapflow-connection.d.ts

@@ -62,6 +62,7 @@ export declare class ImapFlowConnection {
     private _state;
     private config;
     private currentMailbox;
+    private currentMailboxReadOnly;
     constructor(config: ImapConnectionConfig);
     /**
      * Current connection state
@@ -78,6 +79,11 @@ export declare class ImapFlowConnection {
      * Authentication errors are not retried.
      */
     connect: () => Promise<void>;
+    /**
+     * Connect once, without retrying. A failure is classified into a
+     * MailConnectionError where possible and leaves the connection closed.
+     */
+    connectOnce: () => Promise<void>;
     /**
      * Single connection attempt
      */
@@ -357,21 +363,3 @@ export declare class ImapFlowConnection {
      */
     private ensureConnected;
 }
-/**
- * Create an ImapFlow connection from account data using password credentials.
- */
-export declare const createImapFlowConnectionFromAccount: (account: {
-    imapHost: string;
-    imapPort: number;
-    imapTls: boolean;
-    username: string;
-}, password: string) => ImapFlowConnection;
-/**
- * Create an ImapFlow connection using a credentials union (password or OAuth access token).
- */
-export declare const createImapFlowConnectionWithCredentials: (account: {
-    imapHost: string;
-    imapPort: number;
-    imapTls: boolean;
-    username: string;
-}, credentials: import("./types.js").MailCredentials) => ImapFlowConnection;

package/dist/imapflow-connection.js

@@ -149,6 +149,7 @@ export class ImapFlowConnection {
     _state = "disconnected";
     config;
     currentMailbox = null;
+    currentMailboxReadOnly = true;
     constructor(config) {
         this.config = config;
     }
@@ -171,35 +172,35 @@ export class ImapFlowConnection {
      * Authentication errors are not retried.
      */
     connect = async () => {
-        if (this.client) {
-            throw new Error("Already connected");
-        }
         const maxRetries = 3;
         const baseDelayMs = 1000;
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                await this.attemptConnect();
+            const failure = await this.connectOnce().then(() => null, (error) => error);
+            if (failure === null) {
                 return;
             }
-            catch (error) {
-                const classified = classifyImapError(error, `${this.config.host}:${this.config.port}`);
-                // Auth errors won't fix themselves on retry — throw immediately.
-                if (classified?.kind === "auth") {
-                    throw classified;
-                }
-                // Final attempt exhausted: throw the classified error if we have
-                // one (network failures), otherwise let the raw error bubble.
-                if (attempt === maxRetries) {
-                    throw classified ?? error;
-                }
-                // Network and unknown errors fall through to retry-with-backoff.
-                // Exponential backoff: 1s, 2s, 4s
-                const delay = baseDelayMs * 2 ** (attempt - 1);
-                await this.sleep(delay);
-                // Reset state for retry
-                this.cleanup();
+            if (failure instanceof MailConnectionError && failure.kind === "auth") {
+                throw failure;
+            }
+            if (attempt === maxRetries) {
+                throw failure;
             }
+            await this.sleep(baseDelayMs * 2 ** (attempt - 1));
+        }
+    };
+    /**
+     * Connect once, without retrying. A failure is classified into a
+     * MailConnectionError where possible and leaves the connection closed.
+     */
+    connectOnce = async () => {
+        if (this.client) {
+            throw new Error("Already connected");
         }
+        await this.attemptConnect().catch((error) => {
+            this.cleanup();
+            throw (classifyImapError(error, `${this.config.host}:${this.config.port}`) ??
+                error);
+        });
     };
     /**
      * Single connection attempt
@@ -223,6 +224,9 @@ export class ImapFlowConnection {
             host: this.config.host,
             port: this.config.port,
             secure: this.config.tls,
+            transport: this.config.transport,
+            connectionTimeout: this.config.connTimeout,
+            greetingTimeout: this.config.connTimeout,
             servername: this.config.tlsOptions?.servername,
             auth,
             tls: tlsOptions,
@@ -356,8 +360,12 @@ export class ImapFlowConnection {
         // Idempotency guard: re-selecting the currently-open mailbox is a no-op
         // SELECT on the wire. `mailbox` exposes the live, already-selected box, so
         // we can return its status without paying for another round-trip — this is
-        // what lets a batch issue one SELECT and many fetches on the same box.
-        if (this.currentMailbox === mailboxPath && this.client?.mailbox) {
+        // what lets a batch issue one SELECT and many fetches on the same box. A
+        // read-only open does not cover a read-write request: a pooled connection
+        // a sync left EXAMINEd must SELECT before a STORE, MOVE or EXPUNGE.
+        if (this.currentMailbox === mailboxPath &&
+            this.client?.mailbox &&
+            (readOnly || !this.currentMailboxReadOnly)) {
             return this.toBoxStatus(this.client.mailbox, readOnly);
         }
         const mailbox = await this.client?.mailboxOpen(mailboxPath, {
@@ -367,6 +375,7 @@ export class ImapFlowConnection {
             throw new Error(`Failed to open mailbox: ${mailboxPath}`);
         }
         this.currentMailbox = mailboxPath;
+        this.currentMailboxReadOnly = readOnly;
         return this.toBoxStatus(mailbox, readOnly);
     };
     /**
@@ -995,6 +1004,9 @@ export class ImapFlowConnection {
             uidValidity: true,
             highestModseq: true,
         });
+        if (status === false) {
+            throw new Error(`IMAP STATUS returned no result for ${mailboxPath}`);
+        }
         const deletedCount = await this.countDeleted(mailboxPath);
         return {
             messages: status.messages ?? 0,
@@ -1052,30 +1064,6 @@ export class ImapFlowConnection {
         }
     };
 }
-/**
- * Create an ImapFlow connection from account data using password credentials.
- */
-export const createImapFlowConnectionFromAccount = (account, password) => {
-    return new ImapFlowConnection({
-        host: account.imapHost,
-        port: account.imapPort,
-        tls: account.imapTls,
-        user: account.username,
-        credentials: { kind: "password", password },
-    });
-};
-/**
- * Create an ImapFlow connection using a credentials union (password or OAuth access token).
- */
-export const createImapFlowConnectionWithCredentials = (account, credentials) => {
-    return new ImapFlowConnection({
-        host: account.imapHost,
-        port: account.imapPort,
-        tls: account.imapTls,
-        user: account.username,
-        credentials,
-    });
-};
 /**
  * Build the imapflow auth object from mail credentials.
  *

package/dist/index.d.ts

@@ -11,8 +11,8 @@ export { type BodySyncQueueConfig, type BodySyncQueueLogger, BodySyncQueueServic
 export { isMessageBodySyncBroken, type ResolveExhaustedBodySyncDeps, type ResolveExhaustedBodySyncInput, type ResolveExhaustedBodySyncResult, resolveExhaustedBodySyncFailures, } from "./body-sync-terminal.js";
 export { backfillClassifications, type ClassificationBackfillCheckpoint, type ClassificationBackfillCheckpointStore, type ClassificationBackfillDeps, type ClassificationBackfillLogger, type ClassificationBackfillOptions, type ClassificationBackfillProgress, type ClassificationBackfillResult, type ClassificationBackfillTotals, } from "./classification-backfill.js";
 export { classifyParsedMessage, extractPrimaryFromEmail, } from "./classify-message.js";
-export { createConnection, createConnectionFromAccount, createConnectionWithCredentials, createManagedConnectionFactory, type ManagedConnectionFactory, } from "./connection-factory.js";
-export { type ImapTestConfig, type SmtpTestConfig, type TestResult, testImapConnection, testSmtpConnection, } from "./connection-test.js";
+export { type ConnectionScope, connectionScope, createConnection, createConnectionWithCredentials, } from "./connection-factory.js";
+export { type ImapTestConfig, testImapConnection, } from "./connection-test.js";
 export { 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 { clauseMatches, type FilterMessage, type LiteralClauseNarrowing, literalClausesMatch, literalClauseTerms, NO_ACTION, selectMoveWinner, } from "./filters/match.js";
@@ -27,7 +27,7 @@ export { classifyPlacement, type FolderPlacement, type PlacementAction, type Pla
 export { classifyDisplayNameCorrespondence, extractOffDomainLinkDomains, extractSenderMismatch, type SenderMismatchContext, type SenderMismatchSignals, } from "./heuristics/senderMismatch.js";
 export { SOCIAL_DOMAINS } from "./heuristics/socialDomains.js";
 export { TRANSACTIONAL_DOMAINS } from "./heuristics/transactionalDomains.js";
-export { createImapFlowConnectionFromAccount, createImapFlowConnectionWithCredentials, ImapFlowConnection, } from "./imapflow-connection.js";
+export { ImapFlowConnection } from "./imapflow-connection.js";
 export { backfillListIds, type ListIdBackfillCheckpoint, type ListIdBackfillCheckpointStore, type ListIdBackfillDeps, type ListIdBackfillLogger, type ListIdBackfillOptions, type ListIdBackfillProgress, type ListIdBackfillResult, type ListIdBackfillTotals, } from "./list-id-backfill.js";
 export { guardConnectionCursor, guardMailboxCursor, isCursorRebuildNeeded, type MailboxCursorCheck, type MailboxCursorGuardDeps, MailboxCursorPausedError, } from "./mailbox-cursor.js";
 export { type CursorRebuildMatch, type CursorRebuildMatchResult, type CursorRebuildRow, type CursorRebuildSnapshot, matchCursorRebuild, } from "./mailbox-cursor-rebuild.js";
@@ -59,5 +59,5 @@ export { extractSearchText, extractSnippetFromEmail, generateSnippet, normalizeS
 export { MoveNotSettledError, NoJunkMailboxError, type SpamReportConfig, type SpamReportLogger, type SpamReportParams, SpamReportService, } from "./spam-report.js";
 export { type ServerUids, type SyncWarningContext, type SyncWarningRound, SyncWarningService, } from "./sync-warning.js";
 export { buildThreadMessageMoveRevert, buildThreadMessageTrashUpdate, buildThreadMessageUndelete, type ThreadMessageRowState, } from "./thread-message-rows.js";
-export type { FlatMailboxInfo, IImapConnection, ImapBoxStatus, ImapConnectionConfig, ImapConnectionState, ImapNamespace, ImapNamespaces, MailboxSyncResult, MailConnectionErrorKind, MailCredentials, } from "./types.js";
+export type { FlatMailboxInfo, IImapConnection, ImapBoxStatus, ImapConnectionConfig, ImapConnectionState, ImapNamespace, ImapNamespaces, ImapTransport, MailboxSyncResult, MailConnectionErrorKind, MailCredentials, } from "./types.js";
 export { MailConnectionError } from "./types.js";

package/dist/index.js

@@ -12,9 +12,9 @@ export { isMessageBodySyncBroken, resolveExhaustedBodySyncFailures, } from "./bo
 export { backfillClassifications, } from "./classification-backfill.js";
 export { classifyParsedMessage, extractPrimaryFromEmail, } from "./classify-message.js";
 // Connection factory
-export { createConnection, createConnectionFromAccount, createConnectionWithCredentials, createManagedConnectionFactory, } from "./connection-factory.js";
+export { connectionScope, createConnection, createConnectionWithCredentials, } from "./connection-factory.js";
 // Connection testing
-export { testImapConnection, testSmtpConnection, } from "./connection-test.js";
+export { testImapConnection, } from "./connection-test.js";
 export { createFilter, listFilters, resolveFilterUpdate, updateFilter, } from "./filter-operations.js";
 export { extractListId, normalizeListId } from "./filters/list-id.js";
 export { clauseMatches, literalClausesMatch, literalClauseTerms, NO_ACTION, selectMoveWinner, } from "./filters/match.js";
@@ -30,7 +30,7 @@ export { classifyDisplayNameCorrespondence, extractOffDomainLinkDomains, extract
 export { SOCIAL_DOMAINS } from "./heuristics/socialDomains.js";
 export { TRANSACTIONAL_DOMAINS } from "./heuristics/transactionalDomains.js";
 // IMAP connection (ImapFlow-based)
-export { createImapFlowConnectionFromAccount, createImapFlowConnectionWithCredentials, ImapFlowConnection, } from "./imapflow-connection.js";
+export { ImapFlowConnection } from "./imapflow-connection.js";
 export { backfillListIds, } from "./list-id-backfill.js";
 export { guardConnectionCursor, guardMailboxCursor, isCursorRebuildNeeded, MailboxCursorPausedError, } from "./mailbox-cursor.js";
 export { matchCursorRebuild, } from "./mailbox-cursor-rebuild.js";

package/dist/message-sync.d.ts

@@ -1,9 +1,8 @@
 import type { IAddressRepository, IEnvelopeRepository, IMailboxRepository, IMailboxSpecialUseRepository, IMessageFlagPushRepository, IMessageFlagRepository, IMessageRepository, IThreadMessageRepository } from "@remit/data-ports";
 import type { JunkRoleMailboxes } from "@remit/data-ports/folder-role";
-import type { ManagedConnectionFactory } from "./connection-factory.js";
 import type { QuarantineService } from "./quarantine.js";
 import type { SyncWarningService } from "./sync-warning.js";
-import type { ImapAddress } from "./types.js";
+import type { IImapConnection, ImapAddress } from "./types.js";
 /**
  * A From address is only usable when it looks like a real mailbox: both parts
  * present, neither is a known "could not parse" sentinel, and the host carries
@@ -63,7 +62,7 @@ export declare const parseHeaderDate: (raw: string | undefined, fallbackMs: numb
     usedFallback: boolean;
 };
 /**
- * @deprecated Use ManagedConnectionFactory instead
+ * @deprecated Pass the IImapConnection to MessageSyncService instead
  */
 export type ImapConnectionFactory = () => {
     connect(): Promise<void>;
@@ -101,7 +100,7 @@ export interface SyncMessagesResult {
  */
 export declare const selectUidsToSync: (allUids: number[], lastSyncUid: number, highWaterMarkUid: number) => number[];
 export declare class MessageSyncService {
-    private connectionFactory;
+    private connection;
     private mailboxService;
     /**
      * The account’s folder-role map. Required, not optional: which folder
@@ -135,7 +134,7 @@ export declare class MessageSyncService {
      */
     private quarantineService?;
     private log;
-    constructor(connectionFactory: ManagedConnectionFactory, mailboxService: IMailboxRepository, 
+    constructor(connection: IImapConnection, mailboxService: IMailboxRepository, 
     /**
      * The account’s folder-role map. Required, not optional: which folder
      * holds the Junk role decides whether a sighting withholds its sender

package/dist/message-sync.js

@@ -147,7 +147,7 @@ const messageIdForSighting = (accountId, mailboxId, msg) => deriveMessageIdFromS
     fromHost: msg.envelope.from?.[0]?.host,
 });
 export class MessageSyncService {
-    connectionFactory;
+    connection;
     mailboxService;
     mailboxSpecialUseService;
     messageService;
@@ -159,7 +159,7 @@ export class MessageSyncService {
     messageFlagService;
     quarantineService;
     log;
-    constructor(connectionFactory, mailboxService, 
+    constructor(connection, mailboxService, 
     /**
      * The account’s folder-role map. Required, not optional: which folder
      * holds the Junk role decides whether a sighting withholds its sender
@@ -186,7 +186,7 @@ export class MessageSyncService {
      * not re-fetched on every round.
      */
     quarantineService) {
-        this.connectionFactory = connectionFactory;
+        this.connection = connection;
         this.mailboxService = mailboxService;
         this.mailboxSpecialUseService = mailboxSpecialUseService;
         this.messageService = messageService;
@@ -227,7 +227,7 @@ export class MessageSyncService {
         }
         const lastSyncUid = mailbox.lastSyncUid || 0;
         const highWaterMarkUid = mailbox.highWaterMarkUid || 0;
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         const box = await connection.openBox(mailboxPath);
         const status = await connection.getMailboxStatus(mailboxPath);
         // Detection: the served UIDVALIDITY may have changed since it was last
@@ -453,7 +453,7 @@ export class MessageSyncService {
         await this.mailboxService.update(accountId, mailboxId, {
             cursorState: MailboxCursorState.rebuilding,
         });
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         const box = await connection.openBox(mailboxPath);
         // Read before the pass, never after: a message arriving while the
         // rebuild runs is absent from the snapshot below, and a HIGHESTMODSEQ
@@ -652,7 +652,7 @@ export class MessageSyncService {
         const { mailbox, accountId, accountConfigId, cursor, box, status, batchSize, } = params;
         const mailboxId = mailbox.mailboxId;
         const mailboxPath = mailbox.fullPath;
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         // Ask from the last COMPLETE mod-sequence, so a group left part-applied
         // by an earlier round is served again in full; its applied members are
         // then dropped by position, without a lookup.
@@ -963,7 +963,7 @@ export class MessageSyncService {
      * Assumes mailbox is already open from fetchUidsToSync.
      */
     async fetchMessageBatch(uids) {
-        const connection = this.connectionFactory.getConnection();
+        const connection = this.connection;
         return await connection.fetchMessages(uids);
     }
     /**
@@ -1004,7 +1004,7 @@ export class MessageSyncService {
      */
     async probeDepartures(mailbox, accountId, applicable) {
         return confirmDepartures({
-            connection: this.connectionFactory.getConnection(),
+            connection: this.connection,
             mailboxService: this.mailboxService,
             messageService: this.messageService,
             log: this.log,

package/dist/node-transport.d.ts

@@ -0,0 +1,2 @@
+import type { ImapTransport } from "imapflow";
+export declare const nodeTransport: () => ImapTransport;

package/dist/node-transport.js

@@ -0,0 +1,8 @@
+import { connect as netConnect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+export const nodeTransport = () => ({
+    connect: ({ host, port, servername, tls, secure }, onConnect) => secure
+        ? tlsConnect({ host, port, servername, ...tls }, onConnect)
+        : netConnect({ host, port }, onConnect),
+    upgrade: (socket, { host, port, servername, tls }, onSecure) => tlsConnect({ socket, host, port, servername, ...tls }, onSecure),
+});

package/dist/test-helpers/fake-imap.d.ts

@@ -91,8 +91,10 @@ export declare class FakeImapConnection implements IImapConnection {
     readonly state: ImapConnectionState;
     readonly isConnected = true;
     private selected;
+    private selectedReadOnly;
     constructor(server: FakeImapServer);
     private open;
+    private writable;
     private uidList;
     connect: () => Promise<void>;
     disconnect: () => Promise<void>;

package/dist/test-helpers/fake-imap.js

@@ -216,6 +216,7 @@ export class FakeImapConnection {
     state = "authenticated";
     isConnected = true;
     selected = null;
+    selectedReadOnly = true;
     constructor(server) {
         this.server = server;
     }
@@ -224,6 +225,13 @@ export class FakeImapConnection {
             throw new Error("No mailbox selected");
         return this.server.folder(this.selected);
     }
+    writable() {
+        const folder = this.open();
+        if (this.selectedReadOnly) {
+            throw imapError("READ-ONLY", `Mailbox is read-only: ${this.selected}`);
+        }
+        return folder;
+    }
     uidList = (uids) => uids.join(",");
     connect = async () => { };
     disconnect = async () => { };
@@ -248,10 +256,11 @@ export class FakeImapConnection {
             };
         });
     };
-    openBox = async (path, readOnly = false) => {
+    openBox = async (path, readOnly = true) => {
         this.server.run(readOnly ? "EXAMINE" : "SELECT", path);
         const folder = this.server.folder(path);
         this.selected = path;
+        this.selectedReadOnly = readOnly;
         return {
             name: path,
             readOnly,
@@ -389,7 +398,7 @@ export class FakeImapConnection {
     }
     touch = (detail, uids, change) => {
         this.server.run("STORE", `${this.selected} ${this.uidList(uids)} ${detail}`);
-        const folder = this.open();
+        const folder = this.writable();
         const modseq = this.server.bumpModseq();
         for (const uid of uids) {
             const stored = folder.messages.get(uid);
@@ -446,7 +455,7 @@ export class FakeImapConnection {
         if (this.server.ignoreNext.delete(verb)) {
             return { destination, uidValidity: target.uidValidity, uidMap };
         }
-        const source = this.open();
+        const source = verb === "MOVE" ? this.writable() : this.open();
         for (const uid of uids) {
             const stored = source.messages.get(uid);
             if (!stored)
@@ -468,7 +477,7 @@ export class FakeImapConnection {
     copyMessages = async (uids, destination) => this.transfer("COPY", uids, destination);
     deleteMessages = async (uids) => {
         this.server.run("EXPUNGE", `${this.selected} ${this.uidList(uids)}`);
-        const folder = this.open();
+        const folder = this.writable();
         let deleted = 0;
         for (const uid of uids) {
             if (folder.messages.delete(uid))

package/dist/test-helpers/test-store.js

@@ -146,7 +146,7 @@ export const silentLog = {
 };
 export const syncFolder = async (store, account, mailbox, imap) => {
     const connection = imap.connection();
-    const service = new MessageSyncService({ getConnection: () => connection, close: async () => { } }, store.mailbox, store.mailboxSpecialUse, store.message, store.envelope, store.address, store.threadMessage, new SyncWarningService(store.syncWarning), silentLog, store.flagPush, store.messageFlag);
+    const service = new MessageSyncService(connection, store.mailbox, store.mailboxSpecialUse, store.message, store.envelope, store.address, store.threadMessage, new SyncWarningService(store.syncWarning), silentLog, store.flagPush, store.messageFlag);
     const synced = [];
     for (;;) {
         const result = await service.syncMessages(mailbox.mailboxId, account.accountId, account.accountConfigId);

package/dist/types.d.ts

@@ -2,6 +2,8 @@
  * Types for the remit-mailbox-service
  */
 import type { Readable } from "node:stream";
+import type { ImapTransport } from "imapflow";
+export type { ImapTransport };
 /**
  * Discriminated union of mail authentication credentials.
  *
@@ -40,14 +42,13 @@ export interface ImapConnectionConfig {
     user: string;
     credentials: MailCredentials;
     tls: boolean;
+    transport: ImapTransport;
     tlsOptions?: {
         rejectUnauthorized?: boolean;
         servername?: string;
     };
-    /** Connection timeout in milliseconds */
+    /** Connection and greeting timeout in milliseconds */
     connTimeout?: number;
-    /** Authentication timeout in milliseconds */
-    authTimeout?: number;
 }
 /**
  * IMAP connection state

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/mailbox-service",
-	"version": "0.0.114",
+	"version": "0.0.116",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -21,6 +21,10 @@
 			"types": "./dist/imapflow-connection.d.ts",
 			"default": "./dist/imapflow-connection.js"
 		},
+		"./node-transport": {
+			"types": "./dist/node-transport.d.ts",
+			"default": "./dist/node-transport.js"
+		},
 		"./account-credentials": {
 			"types": "./dist/account-credentials.d.ts",
 			"default": "./dist/account-credentials.js"
@@ -55,9 +59,8 @@
 		"better-sqlite3": "^12.11.1"
 	},
 	"dependencies": {
-		"imapflow": "^1.3.3",
+		"imapflow": "^2.9.1",
 		"mailparser": "3.12.2",
-		"nodemailer": "^10.0.6",
 		"p-map": "^7.0.4",
 		"tldts": "^7.4.9",
 		"@remit/data-ports": "*",
@@ -69,7 +72,6 @@
 		"natural": "^8.1.1",
 		"stopword": "^3.1.5",
 		"@types/mailparser": "^3.4.6",
-		"@types/nodemailer": "^8.0.1",
 		"@types/stopword": "^2.0.3",
 		"@remit/calendar-service": "*"
 	},