dsh-email 0.11.0 → 0.13.0

package/lib/mail-client.js

@@ -3,7 +3,7 @@ import nodemailer from 'nodemailer';
 import { mkdir, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { getFreshAccessToken, OAuth2Error } from './oauth2.js';
-import { flattenAddresses, parseRawMessage, sanitizeFilename } from './parse.js';
+import { flattenAddresses, parseRawMessage, sanitizeFilename, stripHtml, truncateText } from './parse.js';
 export class MailError extends Error {
     constructor(message) {
         super(message);
@@ -41,8 +41,8 @@ export function redactCredentials(text) {
  */
 export function imapAuthOf(cfg, accessToken) {
     return cfg.authKind === 'oauth2'
-        ? { user: cfg.user, accessToken: accessToken ?? '' }
-        : { user: cfg.user, pass: cfg.password };
+        ? { user: cfg.authUser, accessToken: accessToken ?? '' }
+        : { user: cfg.authUser, pass: cfg.authPassword };
 }
 /**
  * Nodemailer consumes an OAuth2 token through accessToken, not pass.
@@ -50,8 +50,8 @@ export function imapAuthOf(cfg, accessToken) {
  */
 export function smtpAuthOf(cfg, accessToken) {
     return cfg.authKind === 'oauth2'
-        ? { type: 'OAuth2', user: cfg.user, accessToken: accessToken ?? '' }
-        : { user: cfg.user, pass: cfg.password };
+        ? { type: 'OAuth2', user: cfg.authUser, accessToken: accessToken ?? '' }
+        : { user: cfg.authUser, pass: cfg.authPassword };
 }
 /** The message an OAuth2 account gets when the mailbox has to be logged into again. */
 export const OAUTH2_RELOGIN_MESSAGE = '邮箱登录失败：请到设置页重新登录（Microsoft 账号使用设备码登录，不使用授权码）';
@@ -118,6 +118,43 @@ export function selectAttachmentPart(readAttachments, parts, index) {
     const byTypeAndSize = parts.find(part => part.contentType === meta.contentType && Math.abs(part.size - meta.size) <= tolerance);
     return byTypeAndSize;
 }
+/**
+ * Leaf text/* parts that can carry the message body, attachment parts excluded.
+ * This is what email_read / the search fallback fetch instead of the whole
+ * source: a 20 MiB attachment must not be downloaded just to read the text.
+ */
+function collectTextParts(node, out = []) {
+    if (node === null || node === undefined || typeof node !== 'object')
+        return out;
+    // message/rfc822 整段是一封内嵌邮件（附件），它的正文分段不是本封的正文。
+    if (typeof node.type === 'string' && node.type.toLowerCase().startsWith('message/rfc822'))
+        return out;
+    const children = Array.isArray(node.childNodes) ? node.childNodes : [];
+    if (children.length === 0) {
+        const type = typeof node.type === 'string' ? node.type.toLowerCase() : '';
+        if (type.startsWith('text/') && node.disposition !== 'attachment') {
+            out.push({ key: node.part === undefined || node.part === null ? '1' : String(node.part), type });
+        }
+        return out;
+    }
+    for (const child of children)
+        collectTextParts(child, out);
+    return out;
+}
+/** The body parts worth fetching: text/plain first, text/html as the fallback. */
+function selectBodyParts(node) {
+    const parts = collectTextParts(node);
+    const plain = parts.find(part => part.type === 'text/plain');
+    const html = parts.find(part => part.type === 'text/html');
+    return {
+        ...(plain !== undefined ? { plain } : {}),
+        ...(html !== undefined ? { html } : {}),
+    };
+}
+/** The From header: `user` is the visible address, `senderName` only labels it. */
+function senderOf(cfg) {
+    return cfg.senderName === '' ? cfg.user : { name: cfg.senderName, address: cfg.user };
+}
 /** Case-insensitive match of a query against subject/from/body text. */
 export function messageMatchesQuery(subject, fromText, body, query) {
     const q = query.toLowerCase();
@@ -142,10 +179,11 @@ function formatAddress(entry) {
 }
 function dedupeAddresses(entries, exclude) {
     const seen = new Set();
+    const excluded = new Set((Array.isArray(exclude) ? exclude : [exclude]).map(a => a.trim().toLowerCase()).filter(a => a !== ''));
     const out = [];
     for (const entry of entries) {
         const addr = (entry.address ?? '').toLowerCase();
-        if (addr === '' || addr === exclude || seen.has(addr))
+        if (addr === '' || excluded.has(addr) || seen.has(addr))
             continue;
         seen.add(addr);
         out.push(entry);
@@ -164,7 +202,7 @@ const FORWARD_MAX_CHARS = 4000;
  */
 export function buildReplyMessage(original, mode, selfAddress, text, forwardTo = '') {
     const fromText = original.from.map(a => a.name ?? a.address).filter(Boolean).join(', ') || '(未知发件人)';
-    const self = selfAddress.toLowerCase();
+    const self = (Array.isArray(selfAddress) ? selfAddress : [selfAddress]).filter(a => a.trim() !== '');
     if (mode === 'forward') {
         const to = forwardTo.trim();
         if (to === '')
@@ -231,6 +269,11 @@ function listedFrom(envelope, size, hasAttachments) {
         hasAttachments,
     };
 }
+/** email_attachment reuses the MIME index email_read already parsed; keep a few. */
+const READ_CACHE_MAX = 16;
+const READ_CACHE_TTL_MS = 10 * 60 * 1000;
+/** Folder names change rarely; a short TTL keeps email_folders off the wire. */
+const FOLDER_CACHE_TTL_MS = 60 * 1000;
 /**
  * One mailbox pool for the whole plugin: pooled IMAP connections per
  * account plus pooled SMTP transporters, with idle sweep and error eviction.
@@ -265,6 +308,72 @@ export class EmailPool {
         this.queues.set(name, next.then(() => undefined, () => undefined));
         return next;
     }
+    readCache = new Map();
+    folderCache = new Map();
+    /** UIDVALIDITY 变了以后同一 uid 可能指向另一封邮件，缓存键必须带上它。 */
+    uidValidityOf(client) {
+        const mailbox = client.mailbox;
+        return mailbox === false ? 0 : Number(mailbox.uidValidity ?? 0);
+    }
+    /** Remember a parsed attachment index so email_attachment can skip the refetch. */
+    rememberRead(account, folder, uidValidity, uid, parsed) {
+        const key = account + '\u0000' + folder + '\u0000' + uidValidity + '\u0000' + uid;
+        this.readCache.delete(key);
+        this.readCache.set(key, { ...parsed, at: Date.now() });
+        while (this.readCache.size > READ_CACHE_MAX) {
+            const oldest = this.readCache.keys().next();
+            if (oldest.done === true)
+                break;
+            this.readCache.delete(oldest.value);
+        }
+    }
+    /**
+     * The attachment index for one message: the cached one when email_read already
+     * produced it, otherwise a fresh parse of the full source plus its bodyStructure.
+     */
+    async attachmentIndexOf(client, account, folder, uid, signal) {
+        const uidValidity = this.uidValidityOf(client);
+        const cached = this.recallRead(account, folder, uidValidity, uid);
+        if (cached !== undefined)
+            return cached;
+        // 附件索引只需要 MIME 结构：bodyStructure 已经给出每个附件的 part/名称/大小，
+        // 不必为了拿它先拉整封 source（第一次就下载附件的邮件也一样）。
+        const message = await client.fetchOne(uid, { uid: true, bodyStructure: true }, { uid: true });
+        if (message === false) {
+            throw new MailError('找不到 uid=' + uid + ' 的邮件（可能已被删除，或不在文件夹 "' + folder + '"）');
+        }
+        signal?.throwIfAborted();
+        if (message.bodyStructure !== undefined) {
+            const parts = collectAttachmentParts(message.bodyStructure);
+            const attachments = parts.map(part => ({ filename: part.filename, contentType: part.contentType, size: part.size, part: part.part }));
+            const parsed = { attachments, parts };
+            this.rememberRead(account, folder, uidValidity, uid, parsed);
+            return parsed;
+        }
+        // 服务器没给 bodyStructure：退回整封解析，行为和以前一样。
+        const full = message.source !== undefined
+            ? message
+            : await client.fetchOne(uid, { uid: true, source: true, bodyStructure: true }, { uid: true });
+        if (full === false || full.source === undefined) {
+            throw new MailError('找不到 uid=' + uid + ' 的邮件（可能已被删除，或不在文件夹 "' + folder + '"）');
+        }
+        const body = await parseRawMessage(full.source, this.settings.maxBodyChars);
+        signal?.throwIfAborted();
+        const parsed = { attachments: body.attachments, parts: collectAttachmentParts(full.bodyStructure) };
+        this.rememberRead(account, folder, uidValidity, uid, parsed);
+        return parsed;
+    }
+    recallRead(account, folder, uidValidity, uid) {
+        const key = account + '\u0000' + folder + '\u0000' + uidValidity + '\u0000' + uid;
+        const hit = this.readCache.get(key);
+        if (hit === undefined)
+            return undefined;
+        if (Date.now() - hit.at > READ_CACHE_TTL_MS) {
+            this.readCache.delete(key);
+            return undefined;
+        }
+        return hit;
+    }
     async withImap(accountName, folder, run, readOnly = true, signal) {
         const name = this.resolveName(accountName);
         const cfg = this.account(name);
@@ -525,6 +634,33 @@ export class EmailPool {
             }
         }
     }
+    /**
+     * Download one MIME part through imapflow's decode pipeline: transfer
+     * encoding and charset are handled there, maxBytes caps what is fetched.
+     */
+    async downloadPartText(client, uid, part, maxBytes, signal) {
+        const dl = await client.download(uid, part.key, { uid: true, maxBytes });
+        signal?.throwIfAborted();
+        const buf = await collectStream(dl.content, maxBytes, signal);
+        signal?.throwIfAborted();
+        return buf.toString('utf8');
+    }
+    /**
+     * The message body without its attachments. undefined when the structure has
+     * no usable text part or the server refuses the part fetch, so the caller can
+     * fall back to the full-source path for that one message.
+     */
+    async bodyTextFromParts(client, uid, structure, maxBytes, signal) {
+        const { plain, html } = selectBodyParts(structure);
+        if (plain !== undefined) {
+            const text = await this.downloadPartText(client, uid, plain, maxBytes, signal);
+            if (text.trim() !== '' || html === undefined)
+                return text;
+        }
+        if (html !== undefined)
+            return stripHtml(await this.downloadPartText(client, uid, html, maxBytes, signal));
+        return undefined;
+    }
     async list(accountName, folder, limit, offset, unreadOnly, since, until, signal) {
         const name = this.resolveName(accountName);
         const cfg = this.account(name);
@@ -532,6 +668,8 @@ export class EmailPool {
         return this.withImap(name, folderName, async (client) => {
             const mailbox = client.mailbox;
             const total = mailbox === false ? 0 : mailbox.exists;
+            // imapflow types uidValidity as number | bigint; the wire format is 32-bit.
+            const uidValidity = mailbox === false ? 0 : Number(mailbox.uidValidity ?? 0);
             let scopeCount = total;
             let uids = [];
             const hasDateFilter = since !== undefined || until !== undefined;
@@ -557,10 +695,36 @@ export class EmailPool {
             uids.reverse();
             const window = uids.slice(offset, offset + limit);
             const messages = await this.fetchListed(client, window, signal);
-            return { account: name, count: scopeCount, folder: folderName, messages };
+            return { account: name, count: scopeCount, folder: folderName, uidValidity, messages };
+        }, true, signal);
+    }
+    /**
+     * The uid index behind email_watch: SEARCH UNSEEN only, no envelopes and no
+     * bodies. The caller decides which uids it actually needs to report.
+     */
+    async unseenUids(accountName, folder, signal) {
+        const name = this.resolveName(accountName);
+        const cfg = this.account(name);
+        const folderName = folder || cfg.inboxFolder;
+        return this.withImap(name, folderName, async (client) => {
+            const mailbox = client.mailbox;
+            const uidValidity = mailbox === false ? 0 : Number(mailbox.uidValidity ?? 0);
+            const found = await client.search({ seen: false }, { uid: true });
+            signal?.throwIfAborted();
+            const uids = (found === false ? [] : found).slice().sort((a, b) => b - a);
+            return { account: name, folder: folderName, uidValidity, count: uids.length, uids };
         }, true, signal);
     }
-    async search(accountName, query, folder, limit, since, until, signal) {
+    /** Fetch the envelopes for one uid batch: the rows email_watch will report. */
+    async fetchByUids(accountName, folder, uids, signal) {
+        if (uids.length === 0)
+            return [];
+        const name = this.resolveName(accountName);
+        const cfg = this.account(name);
+        const folderName = folder || cfg.inboxFolder;
+        return this.withImap(name, folderName, (client) => this.fetchListed(client, uids, signal), true, signal);
+    }
+    async search(accountName, query, folder, limit, offset, since, until, signal) {
         const name = this.resolveName(accountName);
         const cfg = this.account(name);
         const folderName = folder || cfg.inboxFolder;
@@ -586,20 +750,28 @@ export class EmailPool {
             signal?.throwIfAborted();
             const uids = [...new Set(found.flatMap(result => result === false ? [] : result))].sort((a, b) => b - a);
             if (uids.length > 0) {
-                const confirmed = await this.searchHits(client, uids, query, limit, signal);
+                // The sample has to cover the requested page (offset + limit) — the same
+                // window the fallback scan looks at — so one FETCH serves both the
+                // verification and the rows that are handed out.
+                const confirmed = await this.searchHits(client, uids, query, offset + limit, signal);
                 if (confirmed.length > 0) {
                     // The server's list holds up, so its size is reported as the match
                     // count; only rows that were confirmed are ever handed out.
-                    return { account: name, query, count: uids.length, folder: folderName, messages: confirmed.slice(0, limit) };
+                    return { account: name, query, count: uids.length, folder: folderName, offset, messages: confirmed.slice(offset, offset + limit) };
                 }
             }
             // Nothing believable came back (empty answer, or hits that did not
             // survive verification): scan the newest messages locally instead.
             if (this.settings.bodySearchFallback) {
-                const messages = await this.searchBodies(client, query, folderName, limit, since, until, signal);
-                return { account: name, query, count: messages.length, folder: folderName, messages };
+                const messages = await this.searchBodies(client, query, folderName, limit, offset, since, until, signal);
+                // 本地扫描不知道全文件夹有多少匹配，count 只是本页条数：用 countKind
+                // 让渲染说「本页 N 条（仅扫描最近 bodySearchLimit 封）」，不能说「共 N 条」。
+                return {
+                    account: name, query, count: messages.length, folder: folderName, offset, messages,
+                    countKind: 'scanned', scannedLimit: this.settings.bodySearchLimit,
+                };
             }
-            return { account: name, query, count: 0, folder: folderName, messages: [] };
+            return { account: name, query, count: 0, folder: folderName, offset, messages: [] };
         }, true, signal);
     }
     /**
@@ -609,8 +781,8 @@ export class EmailPool {
      * the four fields the server was asked about. No body is downloaded here,
      * and uids the server made up simply return nothing.
      */
-    async searchHits(client, uids, query, limit, signal) {
-        const sample = uids.slice(0, Math.min(uids.length, Math.max(this.settings.bodySearchLimit, limit)));
+    async searchHits(client, uids, query, need, signal) {
+        const sample = uids.slice(0, Math.min(uids.length, Math.max(this.settings.bodySearchLimit, need)));
         signal?.throwIfAborted();
         const fetched = await client.fetchAll(sample, { uid: true, envelope: true, flags: true, size: true, bodyStructure: true }, { uid: true });
         signal?.throwIfAborted();
@@ -624,18 +796,19 @@ export class EmailPool {
             .sort((a, b) => b.uid - a.uid);
     }
     /** Client-side scan of the tail of the mailbox, newest first. */
-    async searchBodies(client, query, folder, limit, since, until, signal) {
+    async searchBodies(client, query, folder, limit, offset, since, until, signal) {
         signal?.throwIfAborted();
         const mailbox = client.mailbox;
         const total = mailbox === false ? 0 : mailbox.exists;
         if (total === 0)
             return [];
         const start = Math.max(1, total - this.settings.bodySearchLimit + 1);
-        const fetched = await client.fetchAll(start + ':*', { uid: true, envelope: true, flags: true, size: true, bodyStructure: true, source: true, internalDate: true });
+        // 只取信封与 MIME 结构；正文在下面按 text/* 分段下载，附件不进正文匹配。
+        const fetched = await client.fetchAll(start + ':*', { uid: true, envelope: true, flags: true, size: true, bodyStructure: true, internalDate: true });
         const out = [];
         for (const message of [...fetched].reverse()) {
             signal?.throwIfAborted();
-            if (out.length >= limit)
+            if (out.length >= offset + limit)
                 break;
             const receivedAt = message.internalDate ?? message.envelope?.date;
             if (since !== undefined && (receivedAt === undefined || receivedAt < since))
@@ -647,6 +820,7 @@ export class EmailPool {
                 .map(flattenAddressText).join(' ');
             let body = '';
             if (message.source !== undefined) {
+                // 服务器多送了整封 source（测试/旧行为）：直接解析，不必再多一次往返。
                 try {
                     const parsed = await parseRawMessage(message.source, 4096);
                     signal?.throwIfAborted();
@@ -657,11 +831,20 @@ export class EmailPool {
                     // 单封邮件解析失败不应中断整批回退扫描，继续用 subject/from/to/cc 匹配。
                 }
             }
+            else if (message.bodyStructure !== undefined) {
+                try {
+                    body = await this.bodyTextFromParts(client, message.uid, message.bodyStructure, 4096 * 4, signal) ?? '';
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    // 单封邮件分段下载失败不应中断整批回退扫描，继续用 subject/from/to/cc 匹配。
+                }
+            }
             if (messageMatchesQuery(subject, recipientSearchText, body, query)) {
                 out.push(listedFrom(message, message.size, structureHasAttachment(message.bodyStructure)));
             }
         }
-        return out;
+        return out.slice(offset, offset + limit);
     }
     async fetchListed(client, uids, signal) {
         signal?.throwIfAborted();
@@ -678,12 +861,56 @@ export class EmailPool {
         const cfg = this.account(name);
         const folderName = folder || cfg.inboxFolder;
         return this.withImap(name, folderName, async (client) => {
-            const message = await client.fetchOne(uid, { uid: true, source: true }, { uid: true });
-            if (message === false || message.source === undefined) {
+            // 先只要信封与 MIME 结构，正文按 text/* 分段下载：带 20 MiB 附件的邮件
+            // 只为看正文时不再整封拉下来，附件元数据直接复用 bodyStructure。
+            const message = await client.fetchOne(uid, { uid: true, envelope: true, bodyStructure: true }, { uid: true });
+            if (message === false) {
                 throw new MailError('找不到 uid=' + uid + ' 的邮件（可能已被删除，或不在文件夹 "' + folderName + '"；可用 email_list 重新获取 uid）');
             }
-            const body = await parseRawMessage(message.source, this.settings.maxBodyChars);
             signal?.throwIfAborted();
+            if (message.source === undefined && message.envelope !== undefined && message.bodyStructure !== undefined) {
+                try {
+                    const text = await this.bodyTextFromParts(client, uid, message.bodyStructure, this.settings.maxBodyChars * 4 + 4096, signal);
+                    if (text !== undefined) {
+                        const limited = truncateText(text, this.settings.maxBodyChars);
+                        const parts = collectAttachmentParts(message.bodyStructure);
+                        const attachments = parts.map(part => ({
+                            filename: part.filename,
+                            contentType: part.contentType,
+                            size: part.size,
+                            part: part.part,
+                        }));
+                        this.rememberRead(name, folderName, this.uidValidityOf(client), uid, { attachments, parts });
+                        const envelopeDate = message.envelope.date;
+                        return {
+                            account: name,
+                            uid,
+                            folder: folderName,
+                            date: envelopeDate instanceof Date ? envelopeDate.toISOString() : '',
+                            from: flattenAddresses(message.envelope.from),
+                            to: flattenAddresses(message.envelope.to),
+                            cc: flattenAddresses(message.envelope.cc),
+                            subject: message.envelope.subject ?? '',
+                            text: limited.text,
+                            attachments,
+                            truncated: limited.truncated,
+                        };
+                    }
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    // 分段读取失败（服务器拒绝该分段或结构异常）：这一封退回整封解析。
+                }
+            }
+            const full = message.source !== undefined
+                ? message
+                : await client.fetchOne(uid, { uid: true, source: true, bodyStructure: true }, { uid: true });
+            if (full === false || full.source === undefined) {
+                throw new MailError('找不到 uid=' + uid + ' 的邮件（可能已被删除，或不在文件夹 "' + folderName + '"；可用 email_list 重新获取 uid）');
+            }
+            const body = await parseRawMessage(full.source, this.settings.maxBodyChars);
+            signal?.throwIfAborted();
+            this.rememberRead(name, folderName, this.uidValidityOf(client), uid, { attachments: body.attachments, parts: collectAttachmentParts(full.bodyStructure) });
             return { account: name, uid, folder: folderName, ...body };
         }, true, signal);
     }
@@ -746,17 +973,23 @@ export class EmailPool {
     async folders(accountName, subscribedOnly, signal) {
         const name = this.resolveName(accountName);
         return this.withImap(name, null, async (client) => {
-            const list = await client.list();
-            signal?.throwIfAborted();
-            const folders = list
-                .filter(row => !subscribedOnly || row.subscribed !== false)
-                .map(row => ({
-                name: row.name ?? row.path,
-                path: row.path,
-                specialUse: row.specialUse ?? '',
-                subscribed: row.subscribed !== false,
-            }));
-            return { account: name, folders };
+            const cached = this.folderCache.get(name);
+            let rows;
+            if (cached !== undefined && Date.now() - cached.at < FOLDER_CACHE_TTL_MS) {
+                rows = cached.folders;
+            }
+            else {
+                const list = await client.list();
+                signal?.throwIfAborted();
+                rows = list.map(row => ({
+                    name: row.name ?? row.path,
+                    path: row.path,
+                    specialUse: row.specialUse ?? '',
+                    subscribed: row.subscribed !== false,
+                }));
+                this.folderCache.set(name, { at: Date.now(), folders: rows });
+            }
+            return { account: name, folders: rows.filter(row => !subscribedOnly || row.subscribed !== false) };
         }, true, signal);
     }
     async downloadAttachment(accountName, folder, uid, index, workspaceHint, signal) {
@@ -764,23 +997,19 @@ export class EmailPool {
         const cfg = this.account(name);
         const folderName = folder || cfg.inboxFolder;
         return this.withImap(name, folderName, async (client) => {
-            const message = await client.fetchOne(uid, { uid: true, bodyStructure: true, source: true }, { uid: true });
-            if (message === false || message.source === undefined) {
-                throw new MailError('找不到 uid=' + uid + ' 的邮件（可能已被删除，或不在文件夹 "' + folderName + '"）');
-            }
-            // The mailparser list is authoritative for the index email_read showed;
-            // the bodyStructure walk supplies the IMAP part to download.
-            const body = await parseRawMessage(message.source, this.settings.maxBodyChars);
-            signal?.throwIfAborted();
-            const parts = collectAttachmentParts(message.bodyStructure);
-            if (body.attachments.length === 0)
+            // The mailparser list is authoritative for the index email_read showed and
+            // the bodyStructure walk supplies the IMAP part to download. email_read
+            // already produced both in the usual read-then-download flow, so reuse that
+            // instead of pulling the whole message — attachments included — again.
+            const { attachments, parts } = await this.attachmentIndexOf(client, name, folderName, uid, signal);
+            if (attachments.length === 0)
                 throw new MailError('该邮件没有附件');
-            if (body.attachments[index] === undefined) {
-                throw new MailError('附件序号 ' + index + ' 越界：共 ' + body.attachments.length + ' 个附件（序号从 0 开始，与 email_read 返回的 attachments 顺序一致）');
+            if (attachments[index] === undefined) {
+                throw new MailError('附件序号 ' + index + ' 越界：共 ' + attachments.length + ' 个附件（序号从 0 开始，与 email_read 返回的 attachments 顺序一致）');
             }
-            const att = selectAttachmentPart(body.attachments, parts, index);
+            const att = selectAttachmentPart(attachments, parts, index);
             if (att === undefined) {
-                throw new MailError('附件 #' + index + '（' + body.attachments[index].filename + '）无法在邮件结构中定位（可能是内嵌图片，暂不支持下载）');
+                throw new MailError('附件 #' + index + '（' + attachments[index].filename + '）无法在邮件结构中定位（可能是内嵌图片，暂不支持下载）');
             }
             if (att.size > this.settings.maxAttachmentBytes) {
                 throw new MailError('附件 "' + att.filename + '" 大小 ' + att.size + ' 字节，超过上限 maxAttachmentBytes=' + this.settings.maxAttachmentBytes);
@@ -788,7 +1017,7 @@ export class EmailPool {
             const dl = await client.download(uid, att.part, { uid: true, maxBytes: this.settings.maxAttachmentBytes });
             signal?.throwIfAborted();
             const buf = await collectStream(dl.content, this.settings.maxAttachmentBytes, signal);
-            const safeName = sanitizeFilename(dl.meta.filename ?? att.filename ?? body.attachments[index].filename);
+            const safeName = sanitizeFilename(dl.meta.filename ?? att.filename ?? attachments[index].filename);
             // Default the destination to the session workspace so the model can
             // read the file back; an explicit downloadDir always wins.
             const dir = this.settings.downloadDirExplicit
@@ -809,7 +1038,7 @@ export class EmailPool {
         const cfg = this.account(name);
         const attachments = await validateAttachmentPaths(attachmentPaths ?? [], this.settings.maxAttachmentBytes, signal);
         const info = await this.sendMail(name, cfg, {
-            from: cfg.user,
+            from: senderOf(cfg),
             to,
             cc,
             subject,
@@ -838,10 +1067,13 @@ export class EmailPool {
             const ids = extractMessageIds(message.source);
             const body = await parseRawMessage(message.source, this.settings.maxBodyChars);
             signal?.throwIfAborted();
-            return buildReplyMessage({ from: body.from, to: body.to, cc: body.cc, subject: body.subject, date: body.date, text: body.text, messageId: ids.messageId, references: ids.references }, mode, cfg.user, text, forwardTo);
+            return buildReplyMessage({ from: body.from, to: body.to, cc: body.cc, subject: body.subject, date: body.date, text: body.text, messageId: ids.messageId, references: ids.references }, mode, 
+            // Both the visible address and the login are "me": a reply-all that
+            // keeps either of them would mail the sender his own message.
+            cfg.authUser === cfg.user ? cfg.user : [cfg.user, cfg.authUser], text, forwardTo);
         }, true, signal);
         const info = await this.sendMail(name, cfg, {
-            from: cfg.user,
+            from: senderOf(cfg),
             to: built.to,
             cc,
             subject: built.subject,

package/lib/parse.js

@@ -38,8 +38,10 @@ export function truncateText(text, maxChars) {
     if (text.length <= maxChars)
         return { text, truncated: false };
     const cut = text.slice(0, maxChars);
-    const lastBreak = Math.max(cut.lastIndexOf('\n'), cut.lastIndexOf(' '), 0);
-    return { text: cut.slice(0, lastBreak) + '\n\n…[正文过长，已截断，共 ' + text.length + ' 字符]', truncated: true };
+    const lastBreak = Math.max(cut.lastIndexOf('\n'), cut.lastIndexOf(' '));
+    // 窗口内没有空格/换行时必须硬切：否则 lastBreak 为 0，正文会被整段丢成空串。
+    const head = lastBreak > 0 ? cut.slice(0, lastBreak) : cut;
+    return { text: head + '\n\n…[正文过长，已截断，共 ' + text.length + ' 字符]', truncated: true };
 }
 /**
  * Turn an untrusted attachment filename into a safe basename: no directory

package/lib/runtime.d.ts

@@ -3,7 +3,7 @@ import { type EmailConfig, type ResolvedEmailSettings } from './config.js';
 import { EmailPool } from './mail-client.js';
 import { type EmailSettingsValue } from './settings.js';
 import type { EmailWatchResult } from './types.js';
-export type EmailClient = Pick<EmailPool, 'list' | 'read' | 'mark' | 'search' | 'send' | 'reply' | 'folders' | 'downloadAttachment' | 'startIdleSweep' | 'dispose'>;
+export type EmailClient = Pick<EmailPool, 'list' | 'read' | 'mark' | 'search' | 'send' | 'reply' | 'folders' | 'downloadAttachment' | 'unseenUids' | 'fetchByUids' | 'startIdleSweep' | 'dispose'>;
 export interface EmailSettingsScope {
     get(): unknown;
 }

package/lib/runtime.js

@@ -63,24 +63,42 @@ export function createEmailRuntime(ctx, config, createPool = settings => new Ema
     const watchCursors = new Map();
     const watch = async (account, folder, limit, scope, signal) => {
         const capped = clampInt(limit, 20, 1, 100);
-        const result = await getPool().list(account, folder, 100, 0, true, undefined, undefined, signal);
-        const key = scope + '\u0000' + result.account + '\u0000' + result.folder;
-        const isFirst = !watchCursors.has(key);
-        const cursor = watchCursors.get(key) ?? 0;
-        const fresh = result.messages.filter(message => message.uid > cursor);
-        if (result.messages.length > 0) {
-            watchCursors.set(key, Math.max(cursor, ...result.messages.map(message => message.uid)));
+        const pool = getPool();
+        // 先只 SEARCH UNSEEN 拿 uid 列表与 totalUnread，再只为本轮要报告的最旧
+        // limit 封取信封：网页弹窗每 30 秒轮询一次，不能因为未读多就整批 FETCH。
+        const index = await pool.unseenUids(account, folder, signal);
+        const key = scope + '\u0000' + index.account + '\u0000' + index.folder;
+        const stored = watchCursors.get(key);
+        const uidValidity = typeof index.uidValidity === 'number' ? index.uidValidity : 0;
+        // A UIDVALIDITY change renumbers every message in the mailbox: keeping the
+        // old cursor would either report the whole folder as new or miss everything
+        // that renumbered below it. Re-seed the baseline instead and say so.
+        const reset = stored !== undefined && stored.uidValidity !== 0 && uidValidity !== 0 && stored.uidValidity !== uidValidity;
+        const isFirst = stored === undefined || reset;
+        const cursor = stored === undefined || reset ? 0 : stored.uid;
+        const fresh = isFirst ? [] : index.uids.filter(uid => uid > cursor);
+        // 后续每次只返回 fresh 中最旧的 limit 条，游标也只推进到这批的最大 uid：
+        // 窗口里更旧的新邮件留给下一轮，不能因为本次只返回 limit 条就被永久跳过。
+        const batch = fresh.slice(Math.max(0, fresh.length - capped));
+        const messages = batch.length > 0 ? await pool.fetchByUids(account, folder, batch, signal) : [];
+        if (isFirst) {
+            // 首次调用（或 UIDVALIDITY 重建）只落基线：游标取窗口最新一封，旧邮件不算新邮件。
+            watchCursors.set(key, {
+                uid: index.uids.length > 0 ? index.uids[0] : 0,
+                uidValidity,
+            });
         }
-        else if (isFirst) {
-            watchCursors.set(key, 0);
+        else if (batch.length > 0) {
+            watchCursors.set(key, { uid: Math.max(...batch), uidValidity });
         }
         return {
-            account: result.account,
-            folder: result.folder,
-            firstRun: isFirst,
-            newCount: isFirst ? 0 : fresh.length,
-            messages: (isFirst ? [] : fresh).slice(0, capped),
-            totalUnread: result.count,
+            account: index.account,
+            folder: index.folder,
+            firstRun: stored === undefined,
+            ...(reset ? { reset: true } : {}),
+            newCount: messages.length,
+            messages,
+            totalUnread: index.count,
         };
     };
     const dispose = () => {

package/lib/tool-contract.d.ts

@@ -350,6 +350,9 @@ export declare const watchSchema: {
         firstRun: {
             type: string;
         };
+        reset: {
+            type: string;
+        };
         newCount: {
             type: string;
         };