@remit/imap-worker 0.0.89 → 0.0.91

package/dist/account-check.d.ts

@@ -0,0 +1,27 @@
+import type { AccountItem } from "@remit/data-ports";
+import type { Logger } from "@remit/logger";
+/**
+ * True when `host` is a reserved placeholder name that can never resolve.
+ *
+ * Matches the bare `invalid`/`example` and any subdomain of those namespaces
+ * (`mail.example`, `foo.invalid`, …). Suffix matching is anchored on the dot so
+ * real hosts like `invalid.com` or `imap.gmail.com` are NOT treated as reserved.
+ */
+export declare const isReservedHost: (host: string) => boolean;
+/**
+ * Check if an account's IMAP host can never resolve (reserved TLD).
+ * Returns true if the account should be skipped cleanly — no connection
+ * attempt, no thrown error, so the event is acked rather than dead-lettered.
+ */
+export declare const isUnsyncableHost: (account: AccountItem, log: Logger) => boolean;
+/**
+ * Check if an account is deleted (tombstone pattern).
+ * Returns true if the account should be skipped.
+ */
+export declare const isAccountDeleted: (account: AccountItem, log: Logger) => boolean;
+/**
+ * Check if an account requires re-authentication (e.g. OAuth token revoked).
+ * Returns true if the account should be skipped until the user re-auths.
+ */
+export declare const isAccountReauthRequired: (account: AccountItem, log: Logger) => boolean;
+export declare const isMailSyncDisabled: (account: AccountItem, log: Logger) => boolean;

package/dist/account-check.js

@@ -0,0 +1,70 @@
+import { AccountService } from "@remit/domain-enums";
+/**
+ * RFC 2606 reserved placeholder namespaces that are guaranteed never to resolve
+ * and are not used by any local/dev/e2e environment: `.invalid` (the actual
+ * smoke-test placeholder) and `.example`. An account pointed at one of these can
+ * never connect, so syncing it would retry and dead-letter forever — we skip it.
+ *
+ * `localhost`/`.localhost` and `.test` are deliberately NOT skipped: the e2e and
+ * mailfuzz suites run their IMAP server on `localhost`, and `.test` is commonly
+ * used for local testing.
+ */
+const RESERVED_NAMES = ["invalid", "example"];
+const RESERVED_HOST_SUFFIXES = RESERVED_NAMES.map((name) => `.${name}`);
+/**
+ * True when `host` is a reserved placeholder name that can never resolve.
+ *
+ * Matches the bare `invalid`/`example` and any subdomain of those namespaces
+ * (`mail.example`, `foo.invalid`, …). Suffix matching is anchored on the dot so
+ * real hosts like `invalid.com` or `imap.gmail.com` are NOT treated as reserved.
+ */
+export const isReservedHost = (host) => {
+    const normalized = host.trim().toLowerCase();
+    if (RESERVED_NAMES.includes(normalized)) {
+        return true;
+    }
+    return RESERVED_HOST_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
+};
+/**
+ * Check if an account's IMAP host can never resolve (reserved TLD).
+ * Returns true if the account should be skipped cleanly — no connection
+ * attempt, no thrown error, so the event is acked rather than dead-lettered.
+ */
+export const isUnsyncableHost = (account, log) => {
+    if (isReservedHost(account.imapHost)) {
+        log.warn({ accountId: account.accountId, imapHost: account.imapHost }, "Skipping account: IMAP host is a reserved, never-resolvable name");
+        return true;
+    }
+    return false;
+};
+/**
+ * Check if an account is deleted (tombstone pattern).
+ * Returns true if the account should be skipped.
+ */
+export const isAccountDeleted = (account, log) => {
+    if (account.deletedAt) {
+        log.info({ accountId: account.accountId, deletedAt: account.deletedAt }, "Skipping deleted account");
+        return true;
+    }
+    return false;
+};
+/**
+ * Check if an account requires re-authentication (e.g. OAuth token revoked).
+ * Returns true if the account should be skipped until the user re-auths.
+ */
+export const isAccountReauthRequired = (account, log) => {
+    if (account.connectionState === "reauth_required") {
+        log.info({
+            accountId: account.accountId,
+            connectionState: account.connectionState,
+        }, "Skipping account: reauth required");
+        return true;
+    }
+    return false;
+};
+export const isMailSyncDisabled = (account, log) => {
+    if (account.syncedServices.includes(AccountService.Mail))
+        return false;
+    log.info({ accountId: account.accountId, syncedServices: account.syncedServices }, "Skipping account: mail sync is off");
+    return true;
+};

package/dist/body-sync-gate.d.ts

@@ -0,0 +1,12 @@
+import { SSMClient } from "@aws-sdk/client-ssm";
+import type { Logger } from "@remit/logger";
+/**
+ * Test seam — clears the module-scope TTL cache between unit tests.
+ */
+export declare const resetBodySyncGateCache: () => void;
+/**
+ * Reads the `/{stage}/Remit/bodySyncEnabled` SSM parameter, cached at module
+ * scope for a short TTL. Returns `true` (enabled) when the parameter is absent
+ * or unreadable — body sync fails open so a missing toggle never halts prod.
+ */
+export declare const isBodySyncEnabled: (parameterName: string, log: Logger, ssm?: SSMClient) => Promise<boolean>;

package/dist/body-sync-gate.js

@@ -0,0 +1,53 @@
+import { GetParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+const CACHE_TTL_MS = 30_000;
+let cache;
+let inFlight;
+let defaultClient;
+const getDefaultClient = () => {
+    if (!defaultClient) {
+        defaultClient = new SSMClient({});
+    }
+    return defaultClient;
+};
+/**
+ * Test seam — clears the module-scope TTL cache between unit tests.
+ */
+export const resetBodySyncGateCache = () => {
+    cache = undefined;
+    inFlight = undefined;
+};
+const readParameter = async (ssm, parameterName, log) => {
+    const result = await ssm.send(new GetParameterCommand({ Name: parameterName }));
+    const value = result.Parameter?.Value;
+    if (value === undefined) {
+        log.warn({ parameterName }, "Body-sync toggle parameter missing a value, failing open (enabled)");
+        return true;
+    }
+    return value.trim().toLowerCase() !== "false";
+};
+/**
+ * Reads the `/{stage}/Remit/bodySyncEnabled` SSM parameter, cached at module
+ * scope for a short TTL. Returns `true` (enabled) when the parameter is absent
+ * or unreadable — body sync fails open so a missing toggle never halts prod.
+ */
+export const isBodySyncEnabled = async (parameterName, log, ssm = getDefaultClient()) => {
+    if (cache && cache.expiresAt > Date.now()) {
+        return cache.enabled;
+    }
+    if (inFlight) {
+        return inFlight;
+    }
+    inFlight = readParameter(ssm, parameterName, log)
+        .catch((error) => {
+        log.warn({ parameterName, error }, "Failed to read body-sync toggle parameter, failing open (enabled)");
+        return true;
+    })
+        .then((enabled) => {
+        cache = { enabled, expiresAt: Date.now() + CACHE_TTL_MS };
+        return enabled;
+    })
+        .finally(() => {
+        inFlight = undefined;
+    });
+    return inFlight;
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// Plain text on purpose, and the one deliberate exception to the log field
+// contract in deploy/vps/README.md ("Logs"). That contract covers what a
+// container's log driver ships; this file is the `remit-worker` bin, run by hand
+// against a terminal, and is not an entrypoint of any image (see the target list
+// in npm-scripts/docker-bundle.mjs). Do not route it through the logger — usage
+// text and argument errors are for the person who typed the command.
+import { parseArgs } from "node:util";
+import { getClient } from "@remit/backend/client";
+import { lambdaEmitEvent } from "./lambda-context.js";
+import { sqsWorkerQueues, workerQueueUrlsFromEnv } from "./sqs-queues.js";
+const HELP = `
+remit-imap-worker - Process IMAP sync events
+
+USAGE:
+  remit-worker -t <type> -a <accountId> [options]
+
+OPTIONS:
+  -t, --type <type>         Event type (required)
+  -a, --accountId <id>      Account ID (required)
+  -m, --mailboxId <id>      Mailbox ID (required for some event types)
+      --messageIds <ids>    Comma-separated message IDs (required for SYNC_MESSAGE_BODY)
+      --fullSync            Force full sync, ignoring lastSyncUid (SYNC_MESSAGES only)
+      --path <path>         Mailbox path (required for MAILBOX_CREATE, MAILBOX_DELETE)
+      --oldPath <path>      Old mailbox path (required for MAILBOX_RENAME)
+      --newPath <path>      New mailbox path (required for MAILBOX_RENAME)
+      --subscribe           Subscribe to mailbox after creation (MAILBOX_CREATE only)
+  -h, --help                Show this help message
+
+EVENT TYPES:
+  SYNC_MAILBOXES     Sync all mailboxes for an account
+  SYNC_MESSAGES      Sync messages in a specific mailbox
+  SYNC_MESSAGE_BODY  Fetch and store message bodies in batch
+  MAILBOX_CREATE     Create a new mailbox
+  MAILBOX_RENAME     Rename a mailbox
+  MAILBOX_DELETE     Delete a mailbox
+
+EXAMPLES:
+  # Sync all mailboxes for an account
+  remit-worker -t SYNC_MAILBOXES -a account-123
+
+  # Sync messages in a mailbox
+  remit-worker -t SYNC_MESSAGES -a account-123 -m mailbox-456
+
+  # Force a full sync of messages (ignore lastSyncUid)
+  remit-worker -t SYNC_MESSAGES -a account-123 -m mailbox-456 --fullSync
+
+  # Sync message bodies for specific messages
+  remit-worker -t SYNC_MESSAGE_BODY -a account-123 -m mailbox-456 --messageIds id1,id2,id3
+
+  # Create a new mailbox
+  remit-worker -t MAILBOX_CREATE -a account-123 -m mailbox-id --path Work/Projects --subscribe
+
+  # Rename a mailbox
+  remit-worker -t MAILBOX_RENAME -a account-123 -m mailbox-id --oldPath Work/Projects --newPath Archive/Projects
+
+  # Delete a mailbox
+  remit-worker -t MAILBOX_DELETE -a account-123 -m mailbox-id --path Work/Projects
+`;
+const { values } = parseArgs({
+    options: {
+        type: { type: "string", short: "t" },
+        accountId: { type: "string", short: "a" },
+        mailboxId: { type: "string", short: "m" },
+        messageIds: { type: "string" },
+        fullSync: { type: "boolean", default: false },
+        path: { type: "string" },
+        oldPath: { type: "string" },
+        newPath: { type: "string" },
+        subscribe: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false },
+    },
+});
+if (values.help) {
+    console.log(HELP);
+    process.exit(0);
+}
+if (!values.type || !values.accountId) {
+    console.error("Error: --type and --accountId are required\n");
+    console.log(HELP);
+    process.exit(0);
+}
+const validTypes = [
+    "SYNC_MAILBOXES",
+    "SYNC_MESSAGES",
+    "SYNC_MESSAGE_BODY",
+    "MAILBOX_CREATE",
+    "MAILBOX_RENAME",
+    "MAILBOX_DELETE",
+];
+if (!validTypes.includes(values.type)) {
+    console.error(`Error: Invalid type "${values.type}". Must be one of: ${validTypes.join(", ")}\n`);
+    process.exit(1);
+}
+if (["SYNC_MESSAGES", "SYNC_MESSAGE_BODY"].includes(values.type) &&
+    !values.mailboxId) {
+    console.error(`Error: --mailboxId is required for ${values.type}\n`);
+    process.exit(1);
+}
+if (values.type === "SYNC_MESSAGE_BODY" && !values.messageIds) {
+    console.error(`Error: --messageIds is required for ${values.type}\n`);
+    process.exit(1);
+}
+// Validation for mailbox management events
+if (["MAILBOX_CREATE", "MAILBOX_DELETE"].includes(values.type) &&
+    !values.path) {
+    console.error(`Error: --path is required for ${values.type}\n`);
+    process.exit(1);
+}
+if (["MAILBOX_CREATE", "MAILBOX_RENAME", "MAILBOX_DELETE"].includes(values.type) &&
+    !values.mailboxId) {
+    console.error(`Error: --mailboxId is required for ${values.type}\n`);
+    process.exit(1);
+}
+if (values.type === "MAILBOX_RENAME" && (!values.oldPath || !values.newPath)) {
+    console.error(`Error: --oldPath and --newPath are required for ${values.type}\n`);
+    process.exit(1);
+}
+// Build the event based on type
+const buildEvent = () => {
+    switch (values.type) {
+        case "SYNC_MAILBOXES":
+            return {
+                type: "SYNC_MAILBOXES",
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                accountId: values.accountId,
+            };
+        case "SYNC_MESSAGES":
+            return {
+                type: "SYNC_MESSAGES",
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                accountId: values.accountId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                mailboxId: values.mailboxId,
+                fullSync: values.fullSync,
+            };
+        case "SYNC_MESSAGE_BODY":
+            return {
+                type: "SYNC_MESSAGE_BODY",
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                accountId: values.accountId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                mailboxId: values.mailboxId,
+                messageIds: values.messageIds?.split(",").map((id) => id.trim()),
+            };
+        case "MAILBOX_CREATE":
+            return {
+                type: "MAILBOX_CREATE",
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                accountId: values.accountId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                mailboxId: values.mailboxId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                path: values.path,
+                subscribe: values.subscribe,
+            };
+        case "MAILBOX_RENAME":
+            return {
+                type: "MAILBOX_RENAME",
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                accountId: values.accountId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                mailboxId: values.mailboxId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                oldPath: values.oldPath,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                newPath: values.newPath,
+            };
+        case "MAILBOX_DELETE":
+            return {
+                type: "MAILBOX_DELETE",
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                accountId: values.accountId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                mailboxId: values.mailboxId,
+                // biome-ignore lint/style/noNonNullAssertion: value is guaranteed by caller contract
+                path: values.path,
+            };
+        default:
+            throw new Error(`Unknown event type: ${values.type}`);
+    }
+};
+const event = buildEvent();
+console.log(`Enqueueing ${event.type} event for account ${event.accountId}...`);
+lambdaEmitEvent(sqsWorkerQueues(workerQueueUrlsFromEnv()), (await getClient()).mailboxLock)(event)
+    .then(() => {
+    console.log("Event enqueued successfully");
+    process.exit(0);
+})
+    .catch((error) => {
+    console.error("Failed to enqueue event:", error);
+    process.exit(1);
+});

package/dist/config-env.d.ts

@@ -0,0 +1,5 @@
+import type { ConnectionPoolOptions } from "./connection-pool.js";
+import { type ImapWorkerConfig } from "./context.js";
+export declare const resolveMailboxFreshnessMs: (env: NodeJS.ProcessEnv) => number;
+export declare const imapWorkerConfigFromEnv: (env: NodeJS.ProcessEnv) => ImapWorkerConfig;
+export declare const poolOptionsFromEnv: (env: NodeJS.ProcessEnv) => ConnectionPoolOptions;

package/dist/config-env.js

@@ -0,0 +1,37 @@
+import { attemptBudget } from "@remit/sqs-client/attempt-budget";
+import { DEFAULT_MAILBOX_FRESHNESS_MS, defaultImapWorkerConfig, } from "./context.js";
+import { workerVersion } from "./worker-version.js";
+const DEFAULT_CONNECTIONS_PER_ACCOUNT = 2;
+// Deployments that drive sync from a test harness set MAILBOX_FRESHNESS_MS low
+// so their explicit nudges are never no-oped by the freshness gate.
+export const resolveMailboxFreshnessMs = (env) => {
+    const value = env.MAILBOX_FRESHNESS_MS?.trim();
+    if (!value)
+        return DEFAULT_MAILBOX_FRESHNESS_MS;
+    const raw = Number(value);
+    return Number.isInteger(raw) && raw >= 0 ? raw : DEFAULT_MAILBOX_FRESHNESS_MS;
+};
+export const imapWorkerConfigFromEnv = (env) => {
+    const { attempts } = defaultImapWorkerConfig;
+    return {
+        attempts: {
+            body: attemptBudget("BODY_SYNC_MAX_ATTEMPTS", attempts.body, env),
+            placementMove: attemptBudget("PLACEMENT_MOVE_MAX_ATTEMPTS", attempts.placementMove, env),
+            flagPush: attemptBudget("FLAG_PUSH_MAX_ATTEMPTS", attempts.flagPush, env),
+            appendSent: attemptBudget("APPEND_SENT_MAX_ATTEMPTS", attempts.appendSent, env),
+            messageMove: attemptBudget("MESSAGE_MOVE_MAX_ATTEMPTS", attempts.messageMove, env),
+            messageDelete: attemptBudget("MESSAGE_DELETE_MAX_ATTEMPTS", attempts.messageDelete, env),
+            messageCopy: attemptBudget("MESSAGE_COPY_MAX_ATTEMPTS", attempts.messageCopy, env),
+        },
+        bodyBatchSize: defaultImapWorkerConfig.bodyBatchSize,
+        mailboxFreshnessMs: resolveMailboxFreshnessMs(env),
+        workerVersion: workerVersion(),
+    };
+};
+export const poolOptionsFromEnv = (env) => {
+    const raw = Number(env.CONNECTIONS_PER_ACCOUNT);
+    return {
+        size: Number.isInteger(raw) && raw > 0 ? raw : DEFAULT_CONNECTIONS_PER_ACCOUNT,
+        overflow: "Open",
+    };
+};

package/dist/connection-pool.d.ts

@@ -0,0 +1,22 @@
+import type { ConnectionScope, IImapConnection, MailCredentials } from "@remit/mailbox-service";
+export type PoolOverflow = "Wait" | "Open";
+export interface ConnectionPoolOptions {
+    readonly size: number;
+    readonly overflow: PoolOverflow;
+}
+export interface PoolAccount {
+    readonly accountId: string;
+    readonly username: string;
+    readonly imapHost: string;
+    readonly imapPort: number;
+    readonly imapTls: boolean;
+}
+export type ConnectImap = (account: PoolAccount, credentials: MailCredentials) => ConnectionScope;
+export interface BorrowedConnection {
+    getConnection: () => Promise<IImapConnection>;
+    release: () => Promise<void>;
+}
+export interface ConnectionPool {
+    borrow: (account: PoolAccount, credentials: MailCredentials) => BorrowedConnection;
+}
+export declare const createConnectionPool: (options: ConnectionPoolOptions, connect: ConnectImap) => ConnectionPool;

package/dist/connection-pool.js

@@ -0,0 +1,97 @@
+const isLive = (slot) => slot.connection?.isConnected ?? false;
+const disconnectQuietly = async (slot) => {
+    await slot.scope.disconnect().catch(() => undefined);
+};
+export const createConnectionPool = (options, connect) => {
+    const accounts = new Map();
+    const slotsFor = (accountId) => {
+        const existing = accounts.get(accountId);
+        if (existing)
+            return existing;
+        const created = { slots: [], waiters: [] };
+        accounts.set(accountId, created);
+        return created;
+    };
+    const claim = (pool, createScope) => {
+        const live = pool.slots.find((slot) => !slot.busy && isLive(slot));
+        if (live) {
+            live.busy = true;
+            return { kind: "Pooled", slot: live, state: "Live" };
+        }
+        const stale = pool.slots.find((slot) => !slot.busy);
+        if (stale) {
+            stale.busy = true;
+            return { kind: "Pooled", slot: stale, state: "Stale" };
+        }
+        if (pool.slots.length < options.size) {
+            const slot = { scope: createScope(), connection: null, busy: true };
+            pool.slots.push(slot);
+            return { kind: "Pooled", slot, state: "New" };
+        }
+        return undefined;
+    };
+    const giveBack = (pool, slot) => {
+        const next = pool.waiters.shift();
+        if (next) {
+            next(slot);
+            return;
+        }
+        slot.busy = false;
+    };
+    const acquire = async (pool, createScope) => {
+        const claimed = claim(pool, createScope);
+        if (claimed)
+            return claimed;
+        if (options.overflow === "Open") {
+            return {
+                kind: "Overflow",
+                slot: { scope: createScope(), connection: null, busy: true },
+            };
+        }
+        const slot = await new Promise((resolve) => {
+            pool.waiters.push(resolve);
+        });
+        return { kind: "Pooled", slot, state: isLive(slot) ? "Live" : "Stale" };
+    };
+    const borrow = (account, credentials) => {
+        const pool = slotsFor(account.accountId);
+        const createScope = () => connect(account, credentials);
+        let leased;
+        const getConnection = async () => {
+            leased ??= acquire(pool, createScope).then(async (lease) => {
+                if (lease.kind === "Pooled" && lease.state === "Stale") {
+                    await disconnectQuietly(lease.slot);
+                    lease.slot.connection = null;
+                    try {
+                        lease.slot.scope = createScope();
+                    }
+                    catch (error) {
+                        giveBack(pool, lease.slot);
+                        throw error;
+                    }
+                }
+                return lease;
+            });
+            const { slot } = await leased;
+            const connection = await slot.scope.getConnection();
+            slot.connection = connection;
+            return connection;
+        };
+        const release = async () => {
+            if (!leased)
+                return;
+            const pending = leased;
+            leased = undefined;
+            const lease = await pending.catch(() => undefined);
+            if (!lease)
+                return;
+            if (lease.kind === "Overflow") {
+                await disconnectQuietly(lease.slot);
+                return;
+            }
+            giveBack(pool, lease.slot);
+        };
+        return { getConnection, release };
+    };
+    return { borrow };
+};

package/dist/connection-scope.d.ts

@@ -0,0 +1,8 @@
+import { type ConnectionScope, type MailCredentials } from "@remit/mailbox-service";
+export type { ConnectionScope };
+export declare const createConnectionScopeWithCredentials: (account: {
+    username: string;
+    imapHost: string;
+    imapPort: number;
+    imapTls: boolean;
+}, credentials: MailCredentials) => ConnectionScope;

package/dist/connection-scope.js

@@ -0,0 +1,10 @@
+import { connectionScope, } from "@remit/mailbox-service";
+import { nodeTransport } from "@remit/mailbox-service/node-transport";
+export const createConnectionScopeWithCredentials = (account, credentials) => connectionScope({
+    host: account.imapHost,
+    port: account.imapPort,
+    tls: account.imapTls,
+    user: account.username,
+    credentials,
+    transport: nodeTransport(),
+});

package/dist/context.d.ts

@@ -0,0 +1,46 @@
+import type { RemitClient } from "@remit/backend/client";
+import type { Logger, MailFailureKind } from "@remit/logger";
+import type { MailOAuthService } from "@remit/mail-oauth-service";
+import type { ConnectionPool } from "./connection-pool.js";
+import type { WorkerQueues } from "./queues.js";
+export type ImapWorkerQueueName = "sync";
+export type TokenService = Pick<MailOAuthService, "getAccessToken">;
+export type ImapFailureKind = MailFailureKind;
+export interface WorkerMetrics {
+    imapFailure: (operation: string, kind: ImapFailureKind, count: number) => void;
+}
+export interface AccountObjectPage {
+    keys: string[];
+    nextContinuationToken: string | undefined;
+}
+export interface AccountObjectStore {
+    list: (prefix: string, continuationToken: string | undefined) => Promise<AccountObjectPage>;
+    delete: (keys: string[]) => Promise<void>;
+}
+export interface AttemptBudgets {
+    readonly body: number;
+    readonly placementMove: number;
+    readonly flagPush: number;
+    readonly appendSent: number;
+    readonly messageMove: number;
+    readonly messageDelete: number;
+    readonly messageCopy: number;
+}
+export interface ImapWorkerConfig {
+    readonly attempts: AttemptBudgets;
+    readonly bodyBatchSize: number;
+    readonly mailboxFreshnessMs: number;
+    readonly workerVersion: string;
+}
+export interface ProcessContext {
+    readonly client: RemitClient<ImapWorkerQueueName>;
+    readonly queues: WorkerQueues;
+    readonly pool: ConnectionPool;
+    readonly metrics: WorkerMetrics;
+    readonly config: ImapWorkerConfig;
+    readonly log: Logger;
+    readonly oauth: TokenService;
+    readonly accountObjects: AccountObjectStore;
+}
+export declare const DEFAULT_MAILBOX_FRESHNESS_MS = 60000;
+export declare const defaultImapWorkerConfig: Omit<ImapWorkerConfig, "workerVersion">;

package/dist/context.js

@@ -0,0 +1,15 @@
+import { SYNC_WARNING_SURFACE_ATTEMPTS } from "@remit/data-ports/sync-warning-state";
+export const DEFAULT_MAILBOX_FRESHNESS_MS = 60_000;
+export const defaultImapWorkerConfig = {
+    attempts: {
+        body: SYNC_WARNING_SURFACE_ATTEMPTS,
+        placementMove: 3,
+        flagPush: 3,
+        appendSent: 3,
+        messageMove: 3,
+        messageDelete: 3,
+        messageCopy: 3,
+    },
+    bodyBatchSize: 200,
+    mailboxFreshnessMs: DEFAULT_MAILBOX_FRESHNESS_MS,
+};

package/dist/e2e-processor-shim.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};