apple-mail-mcp 2.8.2 → 2.8.3

package/build/services/imapIdle.d.ts

@@ -1,58 +0,0 @@
-import type { ImapConfig } from "../services/imapClient.js";
-/** Minimal event-capable client surface the watcher needs (testable). */
-export interface IdleClient {
-    connect(): Promise<void>;
-    mailboxOpen(path: string): Promise<{
-        exists: number;
-    }>;
-    on(event: "exists", handler: (data: {
-        count: number;
-        prevCount: number;
-    }) => void): void;
-    on(event: "close" | "error", handler: (err?: unknown) => void): void;
-    logout(): Promise<void>;
-}
-export type IdleConnect = (cfg: ImapConfig) => Promise<IdleClient>;
-export interface NewMailEvent {
-    account: string;
-    count: number;
-    prevCount: number;
-}
-export declare class ImapIdleWatcher {
-    private readonly opts;
-    private readonly connect;
-    private readonly mailbox;
-    private readonly reconnectMs;
-    private readonly pollMs;
-    private readonly clients;
-    private readonly timers;
-    private readonly polls;
-    private readonly lastCount;
-    private stopped;
-    constructor(opts: {
-        configs: ImapConfig[];
-        onNewMail: (e: NewMailEvent) => void;
-        connect?: IdleConnect;
-        mailbox?: string;
-        reconnectMs?: number;
-        /** Poll interval (ms) as a fallback for servers that don't push IDLE EXISTS. 0 disables. */
-        pollMs?: number;
-    });
-    /** Begin watching every configured account. Resolves once watches are kicked off. */
-    start(): Promise<void>;
-    /**
-     * Compare an observed message count to the account's baseline and fire
-     * onNewMail on growth. Updates the baseline either way (so an expunge that
-     * lowers the count re-bases without a spurious later fire).
-     */
-    private observe;
-    private watch;
-    /** Polling fallback: re-check the count for servers that don't push EXISTS. */
-    private startPoll;
-    private scheduleReconnect;
-    /** Stop all watches and close connections. */
-    stop(): Promise<void>;
-    /** Accounts currently being watched (test/diagnostics). */
-    watchedAccounts(): string[];
-}
-//# sourceMappingURL=imapIdle.d.ts.map

package/build/services/imapIdle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"imapIdle.d.ts","sourceRoot":"","sources":["../../src/services/imapIdle.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,yEAAyE;AACzE,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IACzF,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;IACrE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAoBD,qBAAa,eAAe;IAaxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,OAAO,CAAC,OAAO,CAAS;gBAGL,IAAI,EAAE;QACrB,OAAO,EAAE,UAAU,EAAE,CAAC;QACtB,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;QACrC,OAAO,CAAC,EAAE,WAAW,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,4FAA4F;QAC5F,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IAQH,qFAAqF;IAC/E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;OAIG;IACH,OAAO,CAAC,OAAO;YASD,KAAK;IAqBnB,+EAA+E;IAC/E,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,iBAAiB;IAoBzB,8CAA8C;IACxC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAW3B,2DAA2D;IAC3D,eAAe,IAAI,MAAM,EAAE;CAG5B"}

package/build/services/imapIdle.js

@@ -1,151 +0,0 @@
-/**
- * IMAP IDLE push notifications (B5).
- *
- * Opt-in (`APPLE_MAIL_MCP_IMAP_IDLE=1`). For each configured IMAP account this
- * opens a *dedicated* long-lived connection (separate from the request pool,
- * since IDLE holds the connection) on INBOX and watches for new arrivals.
- * ImapFlow keeps the mailbox in IDLE automatically and emits an `exists` event
- * when the message count grows; we forward that to a callback, which the server
- * turns into an MCP notification. Dropped connections reconnect with backoff.
- *
- * @module services/imapIdle
- */
-import { ImapFlow } from "imapflow";
-const defaultIdleConnect = async (cfg) => {
-    const client = new ImapFlow({
-        host: cfg.host,
-        port: cfg.port,
-        secure: cfg.secure,
-        auth: { user: cfg.user, pass: cfg.pass },
-        logger: false,
-    });
-    // ImapFlow is an EventEmitter: an 'error' with no listener (e.g. a socket
-    // ETIMEOUT during connect, before watch() attaches its handler) is an
-    // *uncaught* exception that crashes the whole MCP server. Attach a listener
-    // before connect() so a connection error rejects the promise instead — the
-    // caller (watch) catches that and schedules a reconnect.
-    client.on("error", () => { });
-    await client.connect();
-    return client;
-};
-export class ImapIdleWatcher {
-    opts;
-    connect;
-    mailbox;
-    reconnectMs;
-    pollMs;
-    clients = new Map();
-    timers = new Map();
-    polls = new Map();
-    // Per-account baseline message count; growth past it = new mail.
-    lastCount = new Map();
-    stopped = false;
-    constructor(opts) {
-        this.opts = opts;
-        this.connect = opts.connect ?? defaultIdleConnect;
-        this.mailbox = opts.mailbox ?? "INBOX";
-        this.reconnectMs = opts.reconnectMs ?? 15_000;
-        this.pollMs = opts.pollMs ?? 60_000;
-    }
-    /** Begin watching every configured account. Resolves once watches are kicked off. */
-    async start() {
-        this.stopped = false;
-        await Promise.all(this.opts.configs.map((cfg) => this.watch(cfg)));
-    }
-    /**
-     * Compare an observed message count to the account's baseline and fire
-     * onNewMail on growth. Updates the baseline either way (so an expunge that
-     * lowers the count re-bases without a spurious later fire).
-     */
-    observe(label, count) {
-        if (typeof count !== "number")
-            return;
-        const prev = this.lastCount.get(label);
-        if (prev !== undefined && count > prev) {
-            this.opts.onNewMail({ account: label, count, prevCount: prev });
-        }
-        this.lastCount.set(label, count);
-    }
-    async watch(cfg) {
-        if (this.stopped)
-            return;
-        const label = cfg.accountLabel;
-        try {
-            const client = await this.connect(cfg);
-            this.clients.set(label, client);
-            // Real-time path: ImapFlow emits `exists` while idling (where the server
-            // pushes it). `count` is the new total.
-            client.on("exists", (d) => {
-                if (d)
-                    this.observe(label, d.count);
-            });
-            client.on("error", () => this.scheduleReconnect(cfg));
-            client.on("close", () => this.scheduleReconnect(cfg));
-            const mb = await client.mailboxOpen(this.mailbox); // keeps mailbox open / idling
-            this.lastCount.set(label, mb.exists); // baseline at start of watch
-            this.startPoll(cfg);
-        }
-        catch {
-            this.scheduleReconnect(cfg);
-        }
-    }
-    /** Polling fallback: re-check the count for servers that don't push EXISTS. */
-    startPoll(cfg) {
-        if (this.pollMs <= 0)
-            return;
-        const label = cfg.accountLabel;
-        const existing = this.polls.get(label);
-        if (existing)
-            clearInterval(existing);
-        const p = setInterval(() => {
-            const client = this.clients.get(label);
-            if (!client)
-                return;
-            void client
-                .mailboxOpen(this.mailbox)
-                .then((mb) => this.observe(label, mb.exists))
-                .catch(() => this.scheduleReconnect(cfg));
-        }, this.pollMs);
-        p.unref?.();
-        this.polls.set(label, p);
-    }
-    scheduleReconnect(cfg) {
-        if (this.stopped)
-            return;
-        const label = cfg.accountLabel;
-        if (this.timers.has(label))
-            return; // a reconnect is already pending
-        const poll = this.polls.get(label);
-        if (poll) {
-            clearInterval(poll);
-            this.polls.delete(label);
-        }
-        const old = this.clients.get(label);
-        this.clients.delete(label);
-        if (old)
-            void old.logout().catch(() => undefined);
-        const t = setTimeout(() => {
-            this.timers.delete(label);
-            void this.watch(cfg);
-        }, this.reconnectMs);
-        t.unref?.();
-        this.timers.set(label, t);
-    }
-    /** Stop all watches and close connections. */
-    async stop() {
-        this.stopped = true;
-        for (const t of this.timers.values())
-            clearTimeout(t);
-        for (const p of this.polls.values())
-            clearInterval(p);
-        this.timers.clear();
-        this.polls.clear();
-        const clients = [...this.clients.values()];
-        this.clients.clear();
-        await Promise.all(clients.map((c) => c.logout().catch(() => undefined)));
-    }
-    /** Accounts currently being watched (test/diagnostics). */
-    watchedAccounts() {
-        return [...this.clients.keys()];
-    }
-}

package/build/services/imapMultiAccount.d.ts

@@ -1,124 +0,0 @@
-/**
- * Multi-account read merge (v2.6.0 — prefer-IMAP reads).
- *
- * v2.6.0 flips the read tools to PREFER direct IMAP whenever IMAP is configured
- * (see `shouldUseImap` in imapClient.ts). When a read is issued with NO explicit
- * account, results must still cover EVERY account the user has — so we:
- *
- *   1. fan the IMAP query out over every configured IMAP account
- *      (`resolveImapConfigs()`), and
- *   2. ALSO run the existing AppleScript all-accounts path,
- *
- * then merge the two, de-duplicating any message that appears in both backends
- * (e.g. a Gmail account that is both IMAP-configured AND visible to Mail.app's
- * AppleScript scan) and preferring the IMAP copy (it carries the round-trippable
- * `imap:` id that the mutation tools need).
- *
- * This module holds the backend-agnostic merge/dedup/sort + the per-account IMAP
- * fan-out so the three message-list sites (search-messages, get-thread,
- * list-messages) don't each re-implement it.
- *
- * @module services/imapMultiAccount
- */
-import { type ImapSearchArgs, type ImapConfig, type ImapDeps } from "../services/imapClient.js";
-import type { Account } from "../types.js";
-/** A structured message row as emitted by either backend (permissive on keys). */
-export type MessageRow = Record<string, unknown>;
-/**
- * Cross-backend dedup key for a message row.
- *
- *   - PREFER the normalized Message-ID when present (`mid:<id>`). It's the only
- *     globally-unique identity, so two IMAP accounts that both hold the very
- *     same message (rare, but possible with multi-delivery) collapse to one.
- *   - FALL BACK to `normalizedSubject|sender|dateReceivedEpoch` when no
- *     Message-ID is available. The AppleScript backend never exposes a
- *     Message-ID, so this composite is what actually dedups the common case: a
- *     Gmail account surfaced by BOTH the IMAP fan-out and the AppleScript
- *     all-accounts scan. The IMAP and AppleScript copies of one message share
- *     the same subject, sender, and received timestamp, so they collide here.
- *
- * Limitation (note for live testing): the composite key assumes the two backends
- * report the SAME received timestamp to the second. If Mail.app and the IMAP
- * server disagree on `dateReceived` (timezone/rounding), a message could escape
- * dedup and appear twice. Message-ID dedup (IMAP-vs-IMAP) is exact; the
- * composite is best-effort.
- */
-export declare function dedupKey(row: MessageRow): string;
-/**
- * Merge IMAP rows with AppleScript rows: concatenate, de-dup by {@link dedupKey}
- * preferring the IMAP copy (IMAP rows are passed first and win on collision),
- * sort newest-first by dateReceived, then apply `limit`.
- */
-export declare function mergeMessages(imapRows: MessageRow[], appleRows: MessageRow[], limit: number): MessageRow[];
-/** Gmail/Workspace IMAP host? Its `[Gmail]/All Mail` virtual mailbox is Gmail-only. */
-export declare function isGmailHost(host: string): boolean;
-/**
- * Fan an IMAP message query out over EVERY configured IMAP account and return
- * the concatenated structured rows (not yet merged with AppleScript, not yet
- * limited — the caller merges + limits). `kind` picks the underlying query so
- * the mailbox-default and unreadOnly semantics match the single-account path.
- *
- * Per-account failures are swallowed (logged) so one unreachable account doesn't
- * sink the whole read; the returned `accountsQueried`/`accountsFailed` let the
- * caller surface partial-coverage diagnostics.
- */
-export declare function fanOutImapMessages(args: ImapSearchArgs, kind: "search" | "list", deps?: Omit<ImapDeps, "config" | "account">, configs?: ImapConfig[]): Promise<{
-    rows: MessageRow[];
-    accountsQueried: string[];
-    accountsFailed: string[];
-}>;
-/**
- * Per-pair matcher: does this IMAP config correspond to this Mail.app account?
- * Compared case-insensitively, the config's `accountLabel` AND `user` against the
- * Mail account's `name` AND `email`. An empty email can't match (avoids
- * `"" === ""` false positives). This is the single source of truth for coverage;
- * everything else delegates here.
- */
-export declare function configMatchesAccount(config: ImapConfig, account: Account): boolean;
-/** True when ANY config matches this Mail account (delegates to the per-pair matcher). */
-export declare function isAccountCoveredByImap(account: Account, configs: ImapConfig[]): boolean;
-/**
- * Split Mail.app accounts into those covered by IMAP (counted via IMAP) and the
- * rest (counted via AppleScript), so reads/counts skip the AppleScript scan for
- * IMAP-covered accounts.
- */
-export declare function partitionAccountsForCounts(accounts: Account[], configs: ImapConfig[]): {
-    imapCovered: Account[];
-    appleScriptOnly: Account[];
-};
-/**
- * One unit to count for the count tools (get-unread-count / get-mail-stats),
- * carrying exactly ONE source so every account is counted once and only once:
- *   - `{ kind: "imap", config }`        — count this account via IMAP STATUS;
- *   - `{ kind: "applescript", account }`— count this Mail account via AppleScript.
- */
-export type CountSource = {
-    kind: "imap";
-    config: ImapConfig;
-    label: string;
-} | {
-    kind: "applescript";
-    account: Account;
-    label: string;
-};
-/**
- * Plan the count sources so NO account is double-counted even when the coverage
- * heuristic mis-matches (the failure mode the naive `Σimap(all configs) +
- * Σapple(uncovered)` had: a config that fails to match its Mail account lands in
- * BOTH sums).
- *
- * Account-centric: walk the Mail.app accounts; each is counted via its FIRST
- * matching config (IMAP) or, if none matches, via AppleScript. Then any IMAP
- * config that matched NO Mail account (configured-but-not-present-in-Mail.app) is
- * added once as an IMAP source. A config is consumed by at most one Mail account,
- * so two Mail accounts can't both claim the same config and inflate the total.
- */
-export declare function planCountSources(accounts: Account[], configs: ImapConfig[]): CountSource[];
-/**
- * Render the structured message rows into the human text block the read tools
- * emit (`  - ID: … | date | subject (from: sender) [read|unread]`). Shared so the
- * merged path matches the single-backend formatting. `showReadState` mirrors
- * search/list (which show [read]) vs. plain list rows.
- */
-export declare function formatMergedRows(rows: MessageRow[], showReadState?: boolean): string;
-//# sourceMappingURL=imapMultiAccount.d.ts.map

package/build/services/imapMultiAccount.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"imapMultiAccount.d.ts","sourceRoot":"","sources":["../../src/services/imapMultiAccount.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,kFAAkF;AAClF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAuCjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAMhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,UAAU,EAAE,EACtB,SAAS,EAAE,UAAU,EAAE,EACvB,KAAK,EAAE,MAAM,GACZ,UAAU,EAAE,CAcd;AAED,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,GAAG,MAAM,EACvB,IAAI,GAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAM,EAC/C,OAAO,GAAE,UAAU,EAAyB,GAC3C,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA2BtF;AAmBD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAQlF;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAEvF;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,UAAU,EAAE,GACpB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,eAAe,EAAE,OAAO,EAAE,CAAA;CAAE,CAQxD;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,WAAW,EAAE,CAmB1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,aAAa,UAAO,GAAG,MAAM,CAajF"}

package/build/services/imapMultiAccount.js

@@ -1,253 +0,0 @@
-/**
- * Multi-account read merge (v2.6.0 — prefer-IMAP reads).
- *
- * v2.6.0 flips the read tools to PREFER direct IMAP whenever IMAP is configured
- * (see `shouldUseImap` in imapClient.ts). When a read is issued with NO explicit
- * account, results must still cover EVERY account the user has — so we:
- *
- *   1. fan the IMAP query out over every configured IMAP account
- *      (`resolveImapConfigs()`), and
- *   2. ALSO run the existing AppleScript all-accounts path,
- *
- * then merge the two, de-duplicating any message that appears in both backends
- * (e.g. a Gmail account that is both IMAP-configured AND visible to Mail.app's
- * AppleScript scan) and preferring the IMAP copy (it carries the round-trippable
- * `imap:` id that the mutation tools need).
- *
- * This module holds the backend-agnostic merge/dedup/sort + the per-account IMAP
- * fan-out so the three message-list sites (search-messages, get-thread,
- * list-messages) don't each re-implement it.
- *
- * @module services/imapMultiAccount
- */
-import { imapSearchMessages, imapListMessages, resolveImapConfigs, } from "../services/imapClient.js";
-/**
- * Normalize a Message-ID for comparison: strip surrounding angle brackets and
- * whitespace, lowercase. Returns undefined when the row has no usable id.
- */
-function normalizeMessageId(row) {
-    const raw = typeof row.messageId === "string" ? row.messageId.trim() : "";
-    if (!raw)
-        return undefined;
-    const inner = raw.replace(/^<+|>+$/g, "").trim();
-    return inner ? inner.toLowerCase() : undefined;
-}
-/**
- * Normalize a subject the same way the thread tool does for grouping: drop
- * leading Re:/Fwd: prefixes, collapse whitespace, lowercase. Kept local (and
- * deliberately simple) so the merge has no dependency cycle with the thread
- * module; exactness isn't required — this only feeds the fallback dedup key.
- */
-function normalizeSubjectForKey(subject) {
-    const s = typeof subject === "string" ? subject : "";
-    return s
-        .replace(/^(\s*(re|fwd|fw|aw|sv|antw)\s*:\s*)+/i, "")
-        .replace(/\s+/g, " ")
-        .trim()
-        .toLowerCase();
-}
-/** Epoch ms of the row's dateReceived (ISO string or Date), or 0 when absent. */
-function dateEpoch(row) {
-    const d = row.dateReceived;
-    if (d instanceof Date)
-        return d.getTime();
-    if (typeof d === "string" && d) {
-        const t = new Date(d).getTime();
-        return Number.isNaN(t) ? 0 : t;
-    }
-    return 0;
-}
-/**
- * Cross-backend dedup key for a message row.
- *
- *   - PREFER the normalized Message-ID when present (`mid:<id>`). It's the only
- *     globally-unique identity, so two IMAP accounts that both hold the very
- *     same message (rare, but possible with multi-delivery) collapse to one.
- *   - FALL BACK to `normalizedSubject|sender|dateReceivedEpoch` when no
- *     Message-ID is available. The AppleScript backend never exposes a
- *     Message-ID, so this composite is what actually dedups the common case: a
- *     Gmail account surfaced by BOTH the IMAP fan-out and the AppleScript
- *     all-accounts scan. The IMAP and AppleScript copies of one message share
- *     the same subject, sender, and received timestamp, so they collide here.
- *
- * Limitation (note for live testing): the composite key assumes the two backends
- * report the SAME received timestamp to the second. If Mail.app and the IMAP
- * server disagree on `dateReceived` (timezone/rounding), a message could escape
- * dedup and appear twice. Message-ID dedup (IMAP-vs-IMAP) is exact; the
- * composite is best-effort.
- */
-export function dedupKey(row) {
-    const mid = normalizeMessageId(row);
-    if (mid)
-        return `mid:${mid}`;
-    const subject = normalizeSubjectForKey(row.subject);
-    const sender = (typeof row.sender === "string" ? row.sender : "").trim().toLowerCase();
-    return `k:${subject}|${sender}|${dateEpoch(row)}`;
-}
-/**
- * Merge IMAP rows with AppleScript rows: concatenate, de-dup by {@link dedupKey}
- * preferring the IMAP copy (IMAP rows are passed first and win on collision),
- * sort newest-first by dateReceived, then apply `limit`.
- */
-export function mergeMessages(imapRows, appleRows, limit) {
-    const byKey = new Map();
-    // IMAP first so its copy wins; AppleScript only fills keys IMAP didn't supply.
-    for (const r of imapRows) {
-        const k = dedupKey(r);
-        if (!byKey.has(k))
-            byKey.set(k, r);
-    }
-    for (const r of appleRows) {
-        const k = dedupKey(r);
-        if (!byKey.has(k))
-            byKey.set(k, r);
-    }
-    const merged = [...byKey.values()];
-    merged.sort((a, b) => dateEpoch(b) - dateEpoch(a)); // newest first
-    return limit >= 0 ? merged.slice(0, limit) : merged;
-}
-/** Gmail/Workspace IMAP host? Its `[Gmail]/All Mail` virtual mailbox is Gmail-only. */
-export function isGmailHost(host) {
-    return /(^|\.)gmail\.com$/i.test(host.trim());
-}
-/**
- * Fan an IMAP message query out over EVERY configured IMAP account and return
- * the concatenated structured rows (not yet merged with AppleScript, not yet
- * limited — the caller merges + limits). `kind` picks the underlying query so
- * the mailbox-default and unreadOnly semantics match the single-account path.
- *
- * Per-account failures are swallowed (logged) so one unreachable account doesn't
- * sink the whole read; the returned `accountsQueried`/`accountsFailed` let the
- * caller surface partial-coverage diagnostics.
- */
-export async function fanOutImapMessages(args, kind, deps = {}, configs = resolveImapConfigs()) {
-    const rows = [];
-    const accountsQueried = [];
-    const accountsFailed = [];
-    for (const config of configs) {
-        // Default-mailbox resolution is PER-ACCOUNT: the single-account search default
-        // ("[Gmail]/All Mail") is Gmail-only, so fanning it out to a non-Gmail account
-        // (e.g. iCloud) makes that SELECT fail and the account silently drops from the
-        // merged results. When the caller pinned no mailbox, give Gmail hosts their
-        // All-Mail default (undefined → resolved downstream) and every other host a
-        // universal "INBOX". (limit is applied AFTER the cross-account merge so the
-        // global newest-N is correct even when one account dominates.)
-        const mailbox = args.mailbox ?? (isGmailHost(config.host) ? undefined : "INBOX");
-        const perAccountArgs = { ...args, account: undefined, mailbox };
-        try {
-            const res = kind === "search"
-                ? await imapSearchMessages(perAccountArgs, { ...deps, config })
-                : await imapListMessages(perAccountArgs, { ...deps, config });
-            rows.push(...res.messages);
-            accountsQueried.push(config.accountLabel);
-        }
-        catch (e) {
-            accountsFailed.push(config.accountLabel);
-            console.error(`IMAP fan-out failed for account "${config.accountLabel}": ${String(e)}`);
-        }
-    }
-    return { rows, accountsQueried, accountsFailed };
-}
-// ---------------------------------------------------------------------------
-// Account coverage + count partitioning (reads, get-unread-count, get-mail-stats)
-//
-// Coverage is decided per (config, Mail-account) PAIR by configMatchesAccount.
-// - Message-list reads use partitionAccountsForCounts to run AppleScript ONLY
-//   for accounts no IMAP config covers (IMAP fans out over the configs), so an
-//   all-IMAP user runs zero AppleScript and never depends on composite dedup.
-// - Count tools use planCountSources, which assigns each account EXACTLY ONE
-//   source (its matching config, else AppleScript) and adds any config that
-//   matched no account once — so even a heuristic MISS can't double-count.
-//
-// Matching is case-insensitive on the config's accountLabel/user vs. the Mail
-// account's name/email. accountLabel defaults to the login address and users
-// typically set it to the Mail.app account NAME, so checking both against both
-// catches the common setups (label=accountName, label=email, login=email).
-// ---------------------------------------------------------------------------
-/**
- * Per-pair matcher: does this IMAP config correspond to this Mail.app account?
- * Compared case-insensitively, the config's `accountLabel` AND `user` against the
- * Mail account's `name` AND `email`. An empty email can't match (avoids
- * `"" === ""` false positives). This is the single source of truth for coverage;
- * everything else delegates here.
- */
-export function configMatchesAccount(config, account) {
-    const name = account.name.trim().toLowerCase();
-    const email = (account.email ?? "").trim().toLowerCase();
-    const label = config.accountLabel.trim().toLowerCase();
-    const user = config.user.trim().toLowerCase();
-    return (label === name || (!!email && label === email) || user === name || (!!email && user === email));
-}
-/** True when ANY config matches this Mail account (delegates to the per-pair matcher). */
-export function isAccountCoveredByImap(account, configs) {
-    return configs.some((c) => configMatchesAccount(c, account));
-}
-/**
- * Split Mail.app accounts into those covered by IMAP (counted via IMAP) and the
- * rest (counted via AppleScript), so reads/counts skip the AppleScript scan for
- * IMAP-covered accounts.
- */
-export function partitionAccountsForCounts(accounts, configs) {
-    const imapCovered = [];
-    const appleScriptOnly = [];
-    for (const a of accounts) {
-        if (isAccountCoveredByImap(a, configs))
-            imapCovered.push(a);
-        else
-            appleScriptOnly.push(a);
-    }
-    return { imapCovered, appleScriptOnly };
-}
-/**
- * Plan the count sources so NO account is double-counted even when the coverage
- * heuristic mis-matches (the failure mode the naive `Σimap(all configs) +
- * Σapple(uncovered)` had: a config that fails to match its Mail account lands in
- * BOTH sums).
- *
- * Account-centric: walk the Mail.app accounts; each is counted via its FIRST
- * matching config (IMAP) or, if none matches, via AppleScript. Then any IMAP
- * config that matched NO Mail account (configured-but-not-present-in-Mail.app) is
- * added once as an IMAP source. A config is consumed by at most one Mail account,
- * so two Mail accounts can't both claim the same config and inflate the total.
- */
-export function planCountSources(accounts, configs) {
-    const sources = [];
-    const usedConfigs = new Set();
-    for (const account of accounts) {
-        const match = configs.find((c) => !usedConfigs.has(c) && configMatchesAccount(c, account));
-        if (match) {
-            usedConfigs.add(match);
-            sources.push({ kind: "imap", config: match, label: account.name });
-        }
-        else {
-            sources.push({ kind: "applescript", account, label: account.name });
-        }
-    }
-    // IMAP accounts that exist in config but not in Mail.app — count them once.
-    for (const config of configs) {
-        if (!usedConfigs.has(config)) {
-            sources.push({ kind: "imap", config, label: config.accountLabel });
-        }
-    }
-    return sources;
-}
-/**
- * Render the structured message rows into the human text block the read tools
- * emit (`  - ID: … | date | subject (from: sender) [read|unread]`). Shared so the
- * merged path matches the single-backend formatting. `showReadState` mirrors
- * search/list (which show [read]) vs. plain list rows.
- */
-export function formatMergedRows(rows, showReadState = true) {
-    return rows
-        .map((m) => {
-        const date = (() => {
-            const e = dateEpoch(m);
-            return e ? new Date(e).toLocaleDateString() : "";
-        })();
-        const subject = typeof m.subject === "string" ? m.subject : "(no subject)";
-        const sender = typeof m.sender === "string" ? m.sender : "(unknown)";
-        const state = showReadState ? ` [${m.isRead ? "read" : "unread"}]` : "";
-        return `  - ID: ${String(m.id)} | ${date} | ${subject} (from: ${sender})${state}`;
-    })
-        .join("\n");
-}

package/build/services/messageRouter.d.ts

@@ -1,24 +0,0 @@
-import type { ImapOpResult } from "../services/imapClient.js";
-import { type ToolResponse } from "../tools/respond.js";
-/** True when the id is an IMAP composite token (routes to IMAP). */
-export declare function isImapId(id: string): boolean;
-/**
- * Route a single-message operation to IMAP (when the id is an `imap:` token) or
- * to the AppleScript handler. Maps an IMAP `ImapOpResult` to a tool response,
- * preferring its `info` text on success and `error` on failure.
- */
-export declare function routeMessage(id: string, opts: {
-    imap: () => Promise<ImapOpResult>;
-    apple: () => ToolResponse | Promise<ToolResponse>;
-    ok: string;
-    fail: string;
-    /** Optional ack payload attached as `structuredContent` on the IMAP success
-     *  path, so a caller can verify the mutation programmatically regardless of
-     *  backend (A1). The AppleScript path supplies its own via `apple`. */
-    structured?: Record<string, unknown>;
-    /** Derive `structuredContent` from the IMAP result on success (e.g. parse
-     *  subject/body from `info`). Takes precedence over `structured`; return
-     *  undefined to attach none. */
-    structuredFromResult?: (r: ImapOpResult) => Record<string, unknown> | undefined;
-}): Promise<ToolResponse>;
-//# sourceMappingURL=messageRouter.d.ts.map

package/build/services/messageRouter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messageRouter.d.ts","sourceRoot":"","sources":["../../src/services/messageRouter.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAkC,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvF,oEAAoE;AACpE,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE;IACJ,IAAI,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb;;2EAEuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC;;oCAEgC;IAChC,oBAAoB,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CACjF,GACA,OAAO,CAAC,YAAY,CAAC,CAWvB"}

package/build/services/messageRouter.js

@@ -1,31 +0,0 @@
-/**
- * Central backend router for single-message tools (D1).
- *
- * A single-message id is either an AppleScript numeric id or an `imap:` token.
- * Before this, every message handler (get/mark/flag/move/delete) repeated the
- * same `if (decodeImapId(id)) … else …` branch. `routeMessage` collapses that
- * into one place: run the IMAP op and map its `{success,error,info}` to a tool
- * response, or fall through to the AppleScript handler.
- *
- * @module services/messageRouter
- */
-import { decodeImapId } from "../services/imapClient.js";
-import { successResponse, errorResponse } from "../tools/respond.js";
-/** True when the id is an IMAP composite token (routes to IMAP). */
-export function isImapId(id) {
-    return decodeImapId(id) !== null;
-}
-/**
- * Route a single-message operation to IMAP (when the id is an `imap:` token) or
- * to the AppleScript handler. Maps an IMAP `ImapOpResult` to a tool response,
- * preferring its `info` text on success and `error` on failure.
- */
-export async function routeMessage(id, opts) {
-    if (decodeImapId(id)) {
-        const r = await opts.imap();
-        return r.success
-            ? successResponse(r.info ?? opts.ok, opts.structuredFromResult ? opts.structuredFromResult(r) : opts.structured)
-            : errorResponse(r.error ?? opts.fail);
-    }
-    return opts.apple();
-}