@dumbmice/pi-mailbridge 0.0.0-stage → 0.1.0

package/dist/core/oauth-device.js

@@ -0,0 +1,119 @@
+// Device-code OAuth2 — one auth path for every provider.
+//
+// Microsoft killed app passwords for outlook.com; Gmail keeps them but discourages
+// them; self-hosted boxes may move to OAuth2 next. Rather than write a flow per
+// provider, this module speaks plain OAuth2 **device authorization** (RFC 8628),
+// which every provider we care about supports:
+//
+//   Microsoft (consumers or any tenant)  https://login.microsoftonline.com/consumers/v2.0
+//   Google                              https://accounts.google.com
+//   any OIDC                            your issuer
+//
+// The flow is deliberately the *pull* variant: no redirect URI, no local listener,
+// no browser on the daemon box. You approve on whatever device you like — which is
+// also why the rest of this package can be driven from any device with email.
+//
+// openid-client is reached through an adapter (see core/oauth-openid.ts) so the
+// provider itself is testable and the library stays swappable.
+const DEFAULT_SKEW_MS = 60_000;
+/**
+ * A `TokenProvider` backed by the device-code grant.
+ *
+ * Resolution order: cached access token -> stored refresh token -> fail with an
+ * instruction to run the login command. It never silently degrades to a password:
+ * half-configured auth is worse than a clear error.
+ */
+/** Consecutive refresh failures tolerated before the provider disables itself. */
+const MAX_REFRESH_FAILURES = 3;
+/**
+ * Errors that mean the grant itself is gone, so retrying cannot help.
+ * Everything else (DNS, TLS, timeout, 5xx) is treated as transient.
+ */
+function isCredentialError(error) {
+    const text = error instanceof Error ? `${error.name} ${error.message}` : String(error);
+    return /invalid_grant|invalid_request|unauthorized_client|consent_required|interaction_required|refresh token (?:is )?(?:invalid|expired|revoked)/i.test(text);
+}
+export function createDeviceCodeProvider(options) {
+    const { client, store } = options;
+    const now = options.now ?? (() => Date.now());
+    const skew = options.skewMs ?? DEFAULT_SKEW_MS;
+    let cached;
+    let failures = 0;
+    let disabled = false;
+    let inFlight;
+    function fresh(tokens) {
+        return Boolean(tokens?.accessToken && tokens.expiresAt && tokens.expiresAt - skew > now());
+    }
+    async function acquire() {
+        const stored = store.read();
+        if (fresh(stored)) {
+            cached = { accessToken: stored.accessToken, expiresAt: stored.expiresAt };
+            return cached.accessToken;
+        }
+        if (!stored?.refreshToken) {
+            disabled = true;
+            throw new Error("pi-mailbridge: not authorised yet — run `pi-mailbridge --auth` once to approve device login, or set mail.*.tokenCommand");
+        }
+        try {
+            const refreshed = await client.refresh(stored.refreshToken);
+            cached = refreshed;
+            store.write({
+                ...(refreshed.refreshToken ? { refreshToken: refreshed.refreshToken } : { refreshToken: stored.refreshToken }),
+                accessToken: refreshed.accessToken,
+                expiresAt: refreshed.expiresAt,
+            });
+            failures = 0;
+            return refreshed.accessToken;
+        }
+        catch (error) {
+            failures++;
+            // A revoked grant is permanent: say so now. A network failure is not - disabling
+            // on the first DNS blip stopped every notification until a human restarted pi.
+            const fatal = isCredentialError(error) || failures >= MAX_REFRESH_FAILURES;
+            if (fatal)
+                disabled = true;
+            const reason = error instanceof Error ? error.message : String(error);
+            const suffix = fatal
+                ? " — re-run `pi-mailbridge --auth`"
+                : ` — retrying on next use (${failures}/${MAX_REFRESH_FAILURES})`;
+            throw new Error(`pi-mailbridge: OAuth2 token refresh failed: ${reason}${suffix}`);
+        }
+    }
+    return {
+        async getToken() {
+            if (cached && fresh(cached))
+                return cached.accessToken;
+            if (disabled) {
+                throw new Error(`pi-mailbridge: OAuth2 is disabled after ${failures} failure(s) — re-run \`pi-mailbridge --auth\``);
+            }
+            if (!inFlight) {
+                inFlight = acquire().finally(() => {
+                    inFlight = undefined;
+                });
+            }
+            return inFlight;
+        },
+        invalidate() {
+            cached = undefined;
+            const stored = store.read();
+            if (stored)
+                store.write({ ...stored, accessToken: undefined, expiresAt: undefined });
+        },
+        isDisabled() {
+            return disabled;
+        },
+        state() {
+            return { cached: Boolean(cached && fresh(cached)), disabled, failures };
+        },
+        async login() {
+            const authorization = await client.deviceAuthorization();
+            const tokens = await client.pollDeviceAuthorization();
+            if (!tokens.refreshToken) {
+                throw new Error("pi-mailbridge: the provider returned no refresh_token — make sure `offline_access` is in oauth.scope");
+            }
+            cached = tokens;
+            store.write({ refreshToken: tokens.refreshToken, accessToken: tokens.accessToken, expiresAt: tokens.expiresAt });
+            return authorization;
+        },
+    };
+}

package/dist/core/oauth-openid.js

@@ -0,0 +1,48 @@
+// openid-client adapter.
+//
+// The one place that knows the OAuth library's API. Types are derived from the
+// library itself (`Awaited<ReturnType<...>>`) so a major bump fails the build here
+// rather than producing silently wrong field names.
+import * as oidc from "openid-client";
+/** Map an OAuth token response onto our shape. */
+export function toOAuthTokens(tokens, now = Date.now()) {
+    const lifetime = typeof tokens.expires_in === "number" ? tokens.expires_in : 3600;
+    return {
+        accessToken: tokens.access_token,
+        ...(tokens.refresh_token ? { refreshToken: tokens.refresh_token } : {}),
+        expiresAt: now + lifetime * 1000,
+    };
+}
+/** Human-facing part of a device authorization response. */
+export function toDeviceAuthorization(response) {
+    return {
+        // Prefer the combined URL when the provider offers one: fewer typos.
+        verificationUri: response.verification_uri_complete ?? response.verification_uri,
+        userCode: response.user_code,
+    };
+}
+/**
+ * Build a real OAuth client for `config`.
+ * Async because discovery fetches the provider metadata.
+ */
+export async function createOpenidClient(config, now = Date.now) {
+    const issuer = new URL(config.issuer);
+    const configuration = await oidc.discovery(issuer, config.clientId, config.clientSecret);
+    let pending;
+    return {
+        async deviceAuthorization() {
+            pending = await oidc.initiateDeviceAuthorization(configuration, { scope: config.scope });
+            return toDeviceAuthorization(pending);
+        },
+        async pollDeviceAuthorization() {
+            if (!pending)
+                throw new Error("pi-mailbridge: deviceAuthorization() must run before polling");
+            const tokens = await oidc.pollDeviceAuthorizationGrant(configuration, pending);
+            return toOAuthTokens(tokens, now());
+        },
+        async refresh(refreshToken) {
+            const tokens = await oidc.refreshTokenGrant(configuration, refreshToken);
+            return toOAuthTokens(tokens, now());
+        },
+    };
+}

package/dist/core/oauth.js

@@ -0,0 +1,137 @@
+// OAuth2 access-token supply for XOAUTH2 (Outlook).
+//
+// Microsoft retired SMTP basic auth for outlook.com/hotmail on 2024-09-16, so an
+// app password is not an option there. Two flows are built in - device code
+// (oauth-device.ts) and OpenID Connect (oauth-openid.ts) - and token acquisition can also
+// be delegated to a configurable command whose stdout is the token. This module is the
+// caching/retry layer shared by all three.
+//
+// Two design rules:
+//   1. The command is executed with `execFile` and an argv array — never a shell
+//      — so a token or a path containing shell metacharacters cannot be
+//      reinterpreted as syntax.
+//   2. A broken command disables the provider instead of being retried forever.
+//      The daemon would otherwise spawn a failing process on every scan.
+import { execFile } from "node:child_process";
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Default executor: argv only, bounded output, hard timeout. */
+export const defaultExec = (file, args) => new Promise((resolve, reject) => {
+    execFile(file, args, { timeout: DEFAULT_TIMEOUT_MS, maxBuffer: 1 << 20, shell: false }, (error, stdout) => {
+        if (error) {
+            reject(error);
+            return;
+        }
+        resolve({ stdout: stdout.toString() });
+    });
+});
+const DEFAULT_TTL_MS = 50 * 60 * 1000;
+export function createCommandTokenProvider(options) {
+    const { command } = options;
+    const exec = options.exec ?? defaultExec;
+    const now = options.now ?? (() => Date.now());
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    // "A broken command should not be retried forever" is right; disabling after ONE failure
+    // is not - a DNS blip or a momentary exec failure then stops all mail until a restart.
+    // Three consecutive failures is still quick to notice and survives a transient one.
+    const maxFailures = options.maxConsecutiveFailures ?? 3;
+    let token;
+    let fetchedAt = 0;
+    let failures = 0;
+    let disabled = false;
+    let inFlight;
+    function describeCommand() {
+        // Only argv[0]; later args may contain secrets (client ids, paths).
+        return command[0] ? `${command[0]} …` : "(empty command)";
+    }
+    async function fetchToken() {
+        if (!command.length) {
+            disabled = true;
+            throw new Error("pi-mailbridge: mail.smtp.tokenCommand is empty but authType is XOAUTH2");
+        }
+        try {
+            const { stdout } = await exec(command[0], command.slice(1));
+            const value = stdout.trim().split(/\r?\n/).pop()?.trim() ?? "";
+            if (!value)
+                throw new Error("command produced no output");
+            failures = 0;
+            token = value;
+            fetchedAt = now();
+            return value;
+        }
+        catch (error) {
+            failures++;
+            if (failures >= maxFailures)
+                disabled = true;
+            // Node's execFile message is "Command failed: <file> <all args>\n<stderr>", and the
+            // argv tail is exactly what describeCommand() refuses to print because it may hold a
+            // client secret. Keep the exit shape, drop the rest.
+            const reason = (() => {
+                const raw = error instanceof Error ? error.message : String(error);
+                const code = error?.code;
+                const firstLine = raw.split("\n")[0] ?? "";
+                const withoutArgv = firstLine.replace(/^Command failed: .*$/i, "command failed");
+                const stderr = raw.split("\n").slice(1).join(" ").trim();
+                const detail = stderr ? `${withoutArgv}: ${stderr.slice(0, 200)}` : withoutArgv;
+                return code && !detail.includes(code) ? `${detail} (${code})` : detail;
+            })();
+            const suffix = disabled
+                ? " — OAuth2 is now disabled for this session; fix mail.smtp.tokenCommand and restart"
+                : ` — will retry on next use (${failures}/${maxFailures})`;
+            throw new Error(`pi-mailbridge: OAuth2 token command failed (${describeCommand()}): ${reason}${suffix}`);
+        }
+    }
+    return {
+        async getToken() {
+            if (disabled) {
+                throw new Error(`pi-mailbridge: OAuth2 token provider disabled after ${failures} failure(s) (${describeCommand()}); re-authenticate and restart`);
+            }
+            if (token && now() - fetchedAt < ttlMs)
+                return token;
+            // Collapse concurrent callers onto one exec.
+            if (!inFlight) {
+                inFlight = fetchToken().finally(() => {
+                    inFlight = undefined;
+                });
+            }
+            return inFlight;
+        },
+        invalidate() {
+            token = undefined;
+            fetchedAt = 0;
+        },
+        isDisabled() {
+            return disabled;
+        },
+        state() {
+            return { cached: token !== undefined && now() - fetchedAt < ttlMs, disabled, failures };
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Auth-failure detection + one-shot refresh
+// ---------------------------------------------------------------------------
+/** SMTP/IMAP auth failures as surfacing from the transport or a provider API. */
+const AUTH_ERROR_RE = /(\b401\b|\b535\b|\b534\b|invalid.?credentials?|InvalidAuthenticationToken|AUTHENTICATIONFAILED|token.?(expired|invalid))/i;
+export function isAuthError(error) {
+    const text = error instanceof Error ? `${error.name} ${error.message}` : String(error);
+    return AUTH_ERROR_RE.test(text);
+}
+/**
+ * Run `use(token)`; on an auth error invalidate and retry exactly once.
+ *
+ * One retry, not a loop: a second failure means the credential is genuinely bad,
+ * and retrying forever would hammer the provider and get the account locked.
+ */
+export async function withFreshToken(provider, use, isAuth = isAuthError) {
+    const first = await provider.getToken();
+    try {
+        return await use(first);
+    }
+    catch (error) {
+        if (!isAuth(error))
+            throw error;
+        provider.invalidate();
+        const second = await provider.getToken();
+        return use(second);
+    }
+}

package/dist/core/prime.js

@@ -0,0 +1,51 @@
+// "Watch from now on": skip the mail that is already in the mailbox.
+//
+// This is a first-run decision, not an operation. The scanner polls `UID <cursor>+1:*`, so
+// moving the cursor past unscanned mail makes it permanently invisible to the bridge: no
+// ack, no `\Seen`, no error - just a reply nobody ever answers. That is only possible when a
+// cursor already exists, which is why priming refuses to run a second time (a `/mailbridge
+// on` that processes what arrived meanwhile depends on that cursor staying put).
+//
+// Both the CLI (`--prime`) and the in-pi command go through here, so the two cannot disagree
+// about when it is allowed.
+/**
+ * Decide whether to prime, given the stored cursor and the mailbox's UIDs.
+ *
+ * Pure: the callers do the IMAP work, so the rule is testable without a server.
+ */
+export function planPrime(currentUid, uids, alreadyWatching) {
+    // Neither "the file exists" nor "uid > 0" answers this on its own. The daemon writes the file
+    // on its first connect, before reading anything (a fresh install wants prime); a renumbering
+    // resets the uid to 0 while the mailbox is already being watched (prime would skip exactly
+    // the mail the reset was meant to re-read). The caller passes a flag set by prime itself.
+    if (alreadyWatching)
+        return { ok: false, currentUid };
+    const highest = uids.length > 0 ? Math.max(...uids) : 0;
+    return { ok: true, highest, count: uids.length, currentUid };
+}
+/** The message shown when priming is refused, in both surfaces. */
+export function alreadyPrimedMessage(currentUid) {
+    return (`already watching from uid ${currentUid} - prime is a first-run step, and moving the cursor ` +
+        `now would skip any reply that arrived while the bridge was not scanning. ` +
+        `To re-prime deliberately, remove uid-cursor.json from the state directory.`);
+}
+/**
+ * Run the check, and only touch the cursor when the plan allows it.
+ *
+ * The mailbox is still searched when priming is refused: the count is what makes the refusal
+ * concrete ("3 messages are in that range"), and a search is cheap.
+ */
+export async function runPrime(config, deps) {
+    const mailbox = await deps.openMailbox(config);
+    try {
+        const plan = planPrime(deps.readCursor(), await mailbox.search(), deps.isPrimed());
+        if (plan.ok) {
+            deps.advanceCursor(plan.highest);
+            deps.markPrimed();
+        }
+        return plan;
+    }
+    finally {
+        await mailbox.close().catch(() => undefined);
+    }
+}

package/dist/core/reply-parse.js

@@ -0,0 +1,134 @@
+// Reply parsing: turn a raw mail body into the single line of human intent.
+//
+// Quoted-text stripping is the fragile part of any email bridge — every client
+// quotes differently. The approach here is deliberately blunt: cut at the first
+// recognizable quote boundary and accept the remainder. Being clever (nested
+// quoting, locale heuristics) loses more than it gains.
+//
+// Outbound mail instructs the human to reply *above* the quoted text, so the
+// top of the body is the answer.
+/** Markers that begin a quoted/original section. Matched case-insensitively. */
+const QUOTE_BOUNDARIES = [
+    // "On Tue, 3 Jun 2025 at 09:12, pi <pi@example.com> wrote:"
+    /^\s*On\b.{0,200}\bwrote:\s*$/i,
+    // Outlook / web clients
+    /^\s*-{2,}\s*Original Message\s*-{2,}\s*$/i,
+    // QQ Mail web (Chinese UI) - the primary client for the primary target users:
+    // "------------------ 原始邮件 ------------------" and its 163/126 cousins.
+    /^\s*-{2,}\s*原始邮件\s*-{2,}\s*$/,
+    /^\s*-{2,}\s*原邮件\s*-{2,}\s*$/,
+    // "在 2025年6月3日 09:12，pi <pi@example.com> 写道："
+    /^\s*在\s.{0,120}写道[：:]\s*$/,
+    // "发件人: pi <pi@example.com>" (QQ/163 header block)
+    /^\s*发件人[：:]\s*.+$/,
+    /^\s*_{10,}\s*$/,
+    /^\s*From:\s.+$/i,
+    // "> " quoted block start (BEFORE the boundary scan strips lines)
+    /^\s*>/,
+    // Forwarded-message banner
+    /^\s*-{2,}\s*Forwarded message\s*-{2,}\s*$/i,
+    // Mobile clients
+    /^\s*Sent from my\b/i,
+    // Outlook mobile app signature, in either the English or the Chinese build.
+    /^\s*(?:获取|Get)\s*Outlook\s*for\s+(?:Android|iOS|iPhone|iPad)\b/i,
+];
+/** Signature delimiter per RFC 3676 §4.3 — "dash dash space". */
+const SIGNATURE_DELIM = /^--\s*$/;
+function normalizeNewlines(text) {
+    return text.replace(/\r\n?/g, "\n");
+}
+/**
+ * Strip quoted text and signature from a reply body.
+ *
+ * Returns the top-of-mail content, or `""` when the message carried nothing
+ * new (e.g. the body was entirely quoted). Callers must treat `""` as "no
+ * instruction" and reject — re-injecting the quoted original into the agent
+ * would just replay the agent's own output back at it.
+ */
+export function stripQuoted(raw) {
+    if (!raw)
+        return "";
+    const text = normalizeNewlines(raw);
+    const lines = text.split("\n");
+    const kept = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (SIGNATURE_DELIM.test(line))
+            break;
+        if (QUOTE_BOUNDARIES.some((re) => re.test(line)))
+            break;
+        kept.push(line);
+    }
+    // Drop trailing blank lines.
+    while (kept.length > 0 && kept[kept.length - 1].trim() === "")
+        kept.pop();
+    return kept.join("\n").trim();
+}
+/**
+ * Reduce `"Name" <User@Example.COM>` to `user@example.com`.
+ * Handles bare addresses, angle-addresses, and display names containing commas.
+ */
+export function normalizeAddress(input) {
+    if (!input)
+        return undefined;
+    const angle = /<([^<>]+)>\s*$/.exec(input);
+    const candidate = (angle?.[1] ?? input).trim();
+    // Anything with whitespace left is a display name we could not parse.
+    if (!candidate || /\s/.test(candidate))
+        return undefined;
+    if (!/^[^@\s]+@[^@\s]+$/.test(candidate))
+        return undefined;
+    return candidate.toLowerCase();
+}
+/**
+ * Is this message machine-generated? Replying to one of these is how mail loops
+ * start (out-of-office → us → out-of-office → …).
+ */
+export function isAutoGenerated(headers) {
+    const auto = headers.autoSubmitted?.trim().toLowerCase();
+    if (auto && auto !== "no")
+        return true;
+    const prec = headers.precedence?.trim().toLowerCase();
+    if (prec === "bulk" || prec === "junk" || prec === "list")
+        return true;
+    // Not "any non-empty value": Outlook and corporate gateways stamp this header on ordinary
+    // mail too, and treating presence as machine-generated rejected genuine replies.
+    const suppress = headers.autoResponseSuppress?.trim().toLowerCase() ?? "";
+    if (/\b(oof|autoreply|auto_reply|dr|rn|nrn)\b/.test(suppress))
+        return true;
+    if (headers.listId?.trim())
+        return true;
+    return false;
+}
+/**
+ * Find the `Authentication-Results` header that our own relay added.
+ *
+ * Headers are prepended as a message traverses MTAs, so the TOPMOST
+ * `Authentication-Results` is the one the final hop (your provider) wrote on
+ * delivery. A sender that includes a forged header ends up *below* it, which is
+ * why topmost-wins defeats header forgery — see docs/SECURITY.md §2.1.
+ *
+ * `authservId` pins it further when a provider writes one. It is optional
+ * because Microsoft's consumer relay emits bare headers with no authserv-id
+ * (`Authentication-Results: spf=pass ...; dmarc=pass ...`), and requiring a match
+ * there would reject every piece of genuine mail.
+ */
+export function findTrustedAuthResults(headers, authservId) {
+    const values = headers.authResults ?? [];
+    if (values.length === 0)
+        return undefined;
+    const wanted = authservId?.trim().toLowerCase();
+    if (!wanted)
+        return values[0]; // topmost = the delivering relay's
+    for (const value of values) {
+        const id = /^\s*([^\s;]+)/.exec(value)?.[1]?.toLowerCase();
+        if (id === wanted)
+            return value;
+    }
+    // Pinned but absent: do not silently fall back to an unverified header.
+    return undefined;
+}
+/** `dmarc=pass` inside a specific AR header value. */
+export function dmarcPasses(authResultsValue) {
+    return /\bdmarc\s*=\s*pass\b/i.test(authResultsValue);
+}

package/dist/core/sent-index.js

@@ -0,0 +1,135 @@
+// Record the Message-ID the provider actually delivered.
+//
+// We mint a Message-ID and stamp it, but some providers (QQ among them) replace it on
+// submission: a live test showed our `<uuid@qq.com>` stored in the Sent folder as
+// `<tencent_…@qq.com>`, and the human's reply carried the tencent id in In-Reply-To.
+//
+// The reply-chain fallback matches In-Reply-To against ids we recorded, so on such a provider
+// it never matches - the subject tag is the only remaining route.
+//
+// The just-sent copy is found by the `X-Pi-Mailbridge-Id` header, which carries the id we
+// minted. Two things learned the hard way (a live review caught both):
+//   - the copy is appended *after* the send completes, so this must run after it, and must
+//     retry: QQ took 20-30 s in one measurement;
+//   - matching on the marker header alone records a *different* notification's id when two
+//     sessions send close together, which routes a reply into the wrong session.
+import { recordOutbound } from "../store/threads.js";
+/** Look back far enough to see a send that is still being appended. */
+const CAPTURE_WINDOW_MS = 30 * 60_000;
+/** How many recent sent messages to inspect per attempt. */
+const CAPTURE_SCAN = 20;
+/** Backoff between attempts: providers append asynchronously. */
+const DEFAULT_RETRY_DELAYS_MS = [2_000, 5_000, 15_000, 30_000, 30_000, 30_000];
+/** Pull the first `Message-ID:` out of a header block. */
+export function messageIdFromHeaders(headers) {
+    const unfolded = headers.replace(/\r?\n[ \t]+/g, " ");
+    for (const line of unfolded.split(/\r?\n/)) {
+        const match = /^message-id:\s*<([^>]+)>/i.exec(line.trim());
+        if (match)
+            return match[1].trim();
+    }
+    return undefined;
+}
+/** `X-Pi-Mailbridge-Id: <uuid@domain>` — normalised, without angle brackets. */
+export function stampedIdFromHeaders(headers) {
+    const unfolded = headers.replace(/\r?\n[ \t]+/g, " ");
+    for (const line of unfolded.split(/\r?\n/)) {
+        const match = /^x-pi-mailbridge-id:\s*<?([^>\s]+)>?/i.exec(line.trim());
+        if (match)
+            return match[1].trim();
+    }
+    return undefined;
+}
+/**
+ * Read the just-sent message back from the Sent folder and record its Message-ID for the
+ * session. Best-effort: a failure never fails the send, and one capture runs at a time.
+ */
+export async function captureDeliveredMessageId(options) {
+    const folder = options.config.mail.imap.sentFolder;
+    if (!folder)
+        return undefined;
+    return serialise(options.mintedId, () => attempt(options, folder));
+}
+/**
+ * One capture in flight at a time, and identical requests share it.
+ *
+ * A burst of notifications must not open one connection each, and a capture can hold the
+ * queue for a minute; coalescing means a repeated request for the same minted id costs
+ * nothing extra.
+ */
+let queue = Promise.resolve();
+const inFlightByMintedId = new Map();
+function serialise(key, run) {
+    const existing = inFlightByMintedId.get(key);
+    if (existing)
+        return existing;
+    const next = queue.then(run, run);
+    queue = next.catch(() => undefined);
+    inFlightByMintedId.set(key, next);
+    next.catch(() => undefined).finally(() => inFlightByMintedId.delete(key));
+    return next;
+}
+async function attempt(options, folder) {
+    const env = options.env ?? process.env;
+    const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const delays = options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+    const connect = options.connect ?? (await defaultConnect(options.config, options.getAccessToken));
+    const wanted = options.mintedId.replace(/[<>]/g, "");
+    let client;
+    try {
+        client = await connect();
+        await client.mailboxOpen(folder);
+        for (const delay of delays) {
+            if (delay > 0)
+                await sleep(delay);
+            const since = new Date(Date.now() - CAPTURE_WINDOW_MS);
+            const uids = await client.search({ since }, { uid: true });
+            if (!uids.length)
+                continue;
+            const newestFirst = uids.slice().sort((a, b) => b - a).slice(0, CAPTURE_SCAN);
+            for (const uid of newestFirst) {
+                const fetched = (await client.fetchOne(uid, { source: true }, { uid: true }));
+                if (!fetched || !fetched.source)
+                    continue;
+                const head = (fetched.source.toString("utf8").split(/\r?\n\r?\n/)[0] ?? "").replace(/\r?\n[ \t]+/g, " ");
+                // Only the copy of the message we just sent: the header carries our minted id.
+                if (stampedIdFromHeaders(head) !== wanted)
+                    continue;
+                const messageId = messageIdFromHeaders(head);
+                if (!messageId)
+                    continue;
+                (options.record ?? recordOutbound)(env, {
+                    messageId,
+                    sessionId: options.sessionId,
+                    ...(options.config.device.name ? { device: options.config.device.name } : {}),
+                    subject: options.subject,
+                });
+                return messageId;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await client?.logout().catch(() => undefined);
+    }
+}
+async function defaultConnect(config, getAccessToken) {
+    const { createImapflowFactory } = await import("../daemon/imapflow.js");
+    return async () => {
+        const client = await createImapflowFactory({ ...(getAccessToken ? { getAccessToken } : {}) })(config, {
+            idleRenewMs: config.tuning.idleRenewMs,
+        });
+        try {
+            await client.connect();
+        }
+        catch (error) {
+            // Do not leak the socket of a client whose connect failed.
+            await client.logout().catch(() => undefined);
+            throw error;
+        }
+        return client;
+    };
+}