@zhin.js/adapter-email 3.0.2 → 4.0.0

package/lib/endpoint.js

@@ -1,372 +1,230 @@
 /**
- * Email Endpoint 实现
+ * EmailEndpoint — lifecycle, SMTP outbound, IMAP inbound polling.
  */
-import nodemailer from "nodemailer";
-import Imap from "imap";
-import { simpleParser } from "mailparser";
-import { formatCompact, Message, segment, htmlToPlainTextWithBlockBreaks, expandInteractiveSegmentsInContent, } from 'zhin.js';
-import { EventEmitter } from "events";
-import { createWriteStream, promises as fs } from "fs";
-import path from "path";
-import { fromCanonicalSegments, toCanonicalSegments } from './segment-mapper.js';
-export class EmailEndpoint extends EventEmitter {
-    adapter;
-    $config;
-    $connected = false;
-    smtpTransporter = null;
-    imapConnection = null;
-    checkTimer = null;
-    get logger() {
-        return this.adapter.plugin.logger;
-    }
-    get $id() {
-        return this.$config.name;
-    }
-    constructor(adapter, config) {
-        super();
-        this.adapter = adapter;
-        this.$config = config;
-        // 设置默认值
-        this.$config.imap.checkInterval = this.$config.imap.checkInterval || 60000; // 1分钟
-        this.$config.imap.mailbox = this.$config.imap.mailbox || 'INBOX';
-        this.$config.imap.markSeen = this.$config.imap.markSeen !== false;
-        if (this.$config.attachments?.enabled) {
-            this.$config.attachments.downloadPath = this.$config.attachments.downloadPath || './downloads/email';
-            this.$config.attachments.maxFileSize = this.$config.attachments.maxFileSize || 10 * 1024 * 1024; // 10MB
-        }
-    }
-    async $connect() {
+import { mkdir, writeFile } from 'node:fs/promises';
+import * as path from 'node:path';
+import { simpleParser } from 'mailparser';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { formatInboundContent, formatOutboundMail, parseEmailMessage, senderDisplayName, } from './protocol.js';
+import { defaultCreateImap, defaultCreateSmtp, } from './transport.js';
+const logger = getLogger('email');
+export class EmailEndpoint {
+    #options;
+    #smtp = null;
+    #imap = null;
+    #checkTimer = null;
+    #open = false;
+    #started = false;
+    constructor(options) {
+        this.#options = options;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        const { smtp, imap, name } = this.#options.config;
         try {
-            // 初始化 SMTP 传输器
-            this.smtpTransporter = nodemailer.createTransport({
-                host: this.$config.smtp.host,
-                port: this.$config.smtp.port,
-                secure: this.$config.smtp.secure,
-                auth: this.$config.smtp.auth
-            });
-            // 验证 SMTP 连接
-            await this.smtpTransporter.verify();
-            this.logger.debug(formatCompact({ endpoint: this.$id, mode: "smtp" }));
-            // 初始化 IMAP 连接
-            this.imapConnection = new Imap({
-                user: this.$config.imap.user,
-                password: this.$config.imap.password,
-                host: this.$config.imap.host,
-                port: this.$config.imap.port,
-                tls: this.$config.imap.tls
-            });
-            // 设置 IMAP 事件监听
-            this.setupImapListeners();
-            // 连接 IMAP
+            this.#smtp = await (this.#options.createSmtp?.(smtp) ?? defaultCreateSmtp(smtp));
+            await this.#smtp.verify();
+            logger.debug(formatCompact({ endpoint: name, mode: 'smtp' }));
+            this.#imap = this.#options.createImap?.(imap) ?? defaultCreateImap(imap);
+            this.#setupImapListeners(this.#imap);
             await new Promise((resolve, reject) => {
-                this.imapConnection.once('ready', resolve);
-                this.imapConnection.once('error', reject);
-                this.imapConnection.connect();
+                this.#imap.once('ready', () => resolve());
+                this.#imap.once('error', (error) => reject(error));
+                this.#imap.connect();
             });
-            this.logger.debug(formatCompact({ endpoint: this.$id, mode: "imap" }));
-            // 开始检查邮件
-            this.startEmailCheck();
-            this.$connected = true;
+            logger.debug(formatCompact({ endpoint: name, mode: 'imap' }));
+            this.#startEmailCheck();
         }
         catch (error) {
-            this.logger.error('Failed to connect email services:', error);
+            await this.stop();
+            logger.error('Failed to connect email services:', error);
             throw error;
         }
     }
-    async $disconnect() {
-        this.$connected = false;
-        // 停止定时检查
-        if (this.checkTimer) {
-            clearInterval(this.checkTimer);
-            this.checkTimer = null;
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        if (this.#checkTimer) {
+            clearInterval(this.#checkTimer);
+            this.#checkTimer = null;
         }
-        // 关闭 IMAP 连接
-        if (this.imapConnection) {
-            this.imapConnection.end();
-            this.imapConnection = null;
+        if (this.#imap) {
+            try {
+                this.#imap.end();
+            }
+            catch {
+                /* ignore */
+            }
+            this.#imap = null;
         }
-        // 关闭 SMTP 连接
-        if (this.smtpTransporter) {
-            this.smtpTransporter.close();
-            this.smtpTransporter = null;
+        if (this.#smtp) {
+            try {
+                this.#smtp.close();
+            }
+            catch {
+                /* ignore */
+            }
+            this.#smtp = null;
         }
-        this.logger.debug(formatCompact({ op: "disconnect", endpoint: this.$id }));
+        this.#started = false;
+        logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.name }));
     }
-    setupImapListeners() {
-        if (!this.imapConnection)
+    async send({ target, payload }) {
+        if (!this.#smtp)
+            throw new Error('SMTP transporter not initialized');
+        const mailOptions = formatOutboundMail(payload, {
+            from: this.#options.config.smtp.auth.user,
+            to: target,
+        });
+        const info = await this.#smtp.sendMail(mailOptions);
+        logger.debug(formatCompact({ op: 'email_send', target, messageId: info.messageId }));
+        return info.messageId || '';
+    }
+    /** Test / internal: admit a parsed mail when the endpoint is open. */
+    admit(email) {
+        if (!this.#open)
             return;
-        this.imapConnection.on('mail', (numNewMsgs) => {
-            this.logger.debug(`Received ${numNewMsgs} new emails`);
-            this.checkForNewEmails();
+        void this.#admitWithAttachments(email).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'email_gateway_receive_failed',
+                target: email.from,
+                error: err instanceof Error ? err.message : String(err),
+            }));
         });
-        this.imapConnection.on('error', (error) => {
-            this.logger.error('IMAP error:', error);
+    }
+    async #admitWithAttachments(email) {
+        const savedAttachments = await this.#downloadAttachments(email);
+        const content = formatInboundContent(email);
+        const sender = email.from;
+        await this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: sender,
+            content,
+            sender: senderDisplayName(sender),
+            id: email.messageId || undefined,
+            metadata: Object.freeze({
+                subject: email.subject,
+                to: email.to,
+                cc: email.cc,
+                uid: email.uid,
+                date: email.date.toISOString(),
+                endpoint: this.#options.config.name,
+                ...(savedAttachments.length ? { attachments: savedAttachments } : {}),
+            }),
         });
-        this.imapConnection.on('end', () => {
-            this.logger.debug(formatCompact({ op: "disconnect", endpoint: this.$id, mode: "imap" }));
+    }
+    /**
+     * attachments.enabled 时把入站附件落盘（恢复旧 downloadAttachment 行为，
+     * 附加 maxFileSize / allowedTypes 过滤）；返回落盘结果供 admit metadata 使用。
+     */
+    async #downloadAttachments(email) {
+        const config = this.#options.config.attachments;
+        if (!config?.enabled || email.attachments.length === 0)
+            return [];
+        await mkdir(config.downloadPath, { recursive: true });
+        const saved = [];
+        for (const attachment of email.attachments) {
+            const filename = attachment.filename || `attachment_${Date.now()}`;
+            if (config.allowedTypes?.length && !config.allowedTypes.includes(attachment.contentType ?? '')) {
+                logger.debug(formatCompact({ op: 'email_attachment_skipped', filename, reason: 'type' }));
+                continue;
+            }
+            if (attachment.size != null && attachment.size > config.maxFileSize) {
+                logger.debug(formatCompact({ op: 'email_attachment_skipped', filename, reason: 'size' }));
+                continue;
+            }
+            const filepath = path.join(config.downloadPath, filename);
+            try {
+                await writeFile(filepath, attachment.content);
+                saved.push({ filename, path: filepath, contentType: attachment.contentType, size: attachment.size });
+            }
+            catch (error) {
+                logger.warn(formatCompact({
+                    op: 'email_attachment_download_failed',
+                    filename,
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+            }
+        }
+        return saved;
+    }
+    #setupImapListeners(imap) {
+        imap.on('mail', () => {
+            void this.#checkForNewEmails();
+        });
+        imap.on('error', (error) => {
+            logger.error('IMAP error:', error);
+        });
+        imap.on('end', () => {
+            logger.debug(formatCompact({
+                op: 'disconnect',
+                endpoint: this.#options.config.name,
+                mode: 'imap',
+            }));
         });
     }
-    startEmailCheck() {
-        if (this.checkTimer)
+    #startEmailCheck() {
+        if (this.#checkTimer)
             return;
-        this.checkTimer = setInterval(() => {
-            this.checkForNewEmails();
-        }, this.$config.imap.checkInterval);
-        // 立即检查一次
-        this.checkForNewEmails();
+        this.#checkTimer = setInterval(() => {
+            void this.#checkForNewEmails();
+        }, this.#options.config.imap.checkInterval);
+        void this.#checkForNewEmails();
     }
-    async checkForNewEmails() {
-        if (!this.imapConnection || !this.$connected)
+    async #checkForNewEmails() {
+        if (!this.#imap || !this.#started)
             return;
         try {
             await new Promise((resolve, reject) => {
-                this.imapConnection.openBox(this.$config.imap.mailbox, false, (error, box) => {
+                this.#imap.openBox(this.#options.config.imap.mailbox, false, (error) => {
                     if (error)
                         return reject(error);
-                    // 搜索未读邮件
-                    this.imapConnection.search(['UNSEEN'], (error, results) => {
-                        if (error)
-                            return reject(error);
-                        if (results.length === 0) {
+                    this.#imap.search(['UNSEEN'], (searchError, results) => {
+                        if (searchError)
+                            return reject(searchError);
+                        if (!results.length)
                             return resolve();
-                        }
-                        // 获取邮件
-                        const fetch = this.imapConnection.fetch(results, {
+                        const fetch = this.#imap.fetch(results, {
                             bodies: '',
-                            markSeen: this.$config.imap.markSeen
+                            markSeen: this.#options.config.imap.markSeen,
                         });
                         fetch.on('message', (msg, seqno) => {
-                            this.handleImapMessage(msg, seqno);
+                            this.#handleImapMessage(msg, seqno);
                         });
-                        fetch.once('error', reject);
-                        fetch.once('end', resolve);
+                        fetch.once('error', (fetchError) => reject(fetchError));
+                        fetch.once('end', () => resolve());
                     });
                 });
             });
         }
         catch (error) {
-            this.logger.error('Error checking for new emails:', error);
+            logger.error('Error checking for new emails:', error);
         }
     }
-    handleImapMessage(msg, seqno) {
+    #handleImapMessage(msg, _seqno) {
         let body = '';
         let uid = 0;
         msg.on('body', (stream) => {
             stream.on('data', (chunk) => {
-                body += chunk.toString('utf8');
+                body += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
             });
         });
         msg.once('attributes', (attrs) => {
-            uid = attrs.uid;
-        });
-        msg.once('end', async () => {
-            try {
-                const parsed = await simpleParser(body);
-                const emailMessage = this.parseEmailMessage(parsed, uid);
-                const formattedMessage = this.$formatMessage(emailMessage);
-                this.adapter.emit('message.receive', formattedMessage);
-            }
-            catch (error) {
-                this.logger.error('Error parsing email:', error);
-            }
+            uid = attrs.uid ?? 0;
         });
-    }
-    parseEmailMessage(parsed, uid) {
-        const getAddressText = (addr) => {
-            if (!addr)
-                return [];
-            if (Array.isArray(addr)) {
-                return addr.map((a) => a.text || a.address || a.toString());
-            }
-            return [addr.text || addr.address || addr.toString()];
-        };
-        return {
-            messageId: parsed.messageId || '',
-            from: parsed.from ? getAddressText(parsed.from)[0] || '' : '',
-            to: getAddressText(parsed.to),
-            cc: getAddressText(parsed.cc),
-            bcc: getAddressText(parsed.bcc),
-            subject: parsed.subject || '',
-            text: parsed.text || '',
-            html: parsed.html ? parsed.html.toString() : '',
-            attachments: parsed.attachments || [],
-            date: parsed.date || new Date(),
-            uid
-        };
-    }
-    $formatMessage(emailMsg) {
-        // 确定频道类型和ID
-        const channelType = 'private';
-        const channelId = emailMsg.from;
-        // 解析邮件内容
-        const wire = EmailEndpoint.parseEmailContent(emailMsg);
-        const content = toCanonicalSegments(wire);
-        const result = Message.from(emailMsg, {
-            $id: emailMsg.messageId,
-            $adapter: 'email',
-            $endpoint: this.$config.name,
-            $sender: {
-                id: emailMsg.from,
-                name: emailMsg.from.split('<')[0].trim() || emailMsg.from
-            },
-            $channel: {
-                id: channelId,
-                type: channelType
-            },
-            $raw: JSON.stringify(emailMsg),
-            $timestamp: emailMsg.date.getTime(),
-            $content: content,
-            $recall: async () => {
-                // 邮件适配器暂时不支持撤回消息
-            },
-            $reply: async (content) => {
-                return await this.adapter.sendMessage({
-                    context: this.$config.context,
-                    endpoint: this.$config.name,
-                    id: emailMsg.from,
-                    type: 'private',
-                    content
-                });
-            }
-        });
-        return result;
-    }
-    static parseEmailContent(email) {
-        const segments = [];
-        // 添加主题（如果有且不为空）
-        if (email.subject) {
-            segments.push(segment.text(`Subject: ${email.subject}\n\n`));
-        }
-        // 添加文本内容
-        if (email.text) {
-            segments.push(segment.text(email.text));
-        }
-        // 如果没有纯文本但有HTML，尝试转换
-        if (!email.text && email.html) {
-            const textFromHtml = EmailEndpoint.htmlToText(email.html);
-            if (textFromHtml) {
-                segments.push(segment.text(textFromHtml));
-            }
-        }
-        // 处理附件
-        for (const attachment of email.attachments) {
-            if (attachment.contentType?.startsWith('image/')) {
-                segments.push(segment('image', {
-                    filename: attachment.filename,
-                    contentType: attachment.contentType,
-                    size: attachment.size
-                }));
-            }
-            else {
-                segments.push(segment('file', {
-                    filename: attachment.filename,
-                    contentType: attachment.contentType,
-                    size: attachment.size
-                }));
-            }
-        }
-        return segments.length > 0 ? segments : [segment.text('(Empty email)')];
-    }
-    async $sendMessage(options) {
-        if (!this.smtpTransporter) {
-            throw new Error('SMTP transporter not initialized');
-        }
-        try {
-            const canonical = expandInteractiveSegmentsInContent(options.content);
-            const wire = fromCanonicalSegments(canonical);
-            const mailOptions = await this.formatSendContent({ ...options, content: wire });
-            const info = await this.smtpTransporter.sendMail(mailOptions);
-            this.logger.debug('Email sent:', info.messageId);
-            return info.messageId || '';
-        }
-        catch (error) {
-            this.logger.error('Failed to send email:', error);
-            throw error;
-        }
-    }
-    async $recallMessage(id) {
-        // 邮件适配器暂时不支持撤回消息
-    }
-    async formatSendContent(options) {
-        const mailOptions = {
-            from: this.$config.smtp.auth.user,
-            to: options.id,
-            subject: 'Message from Bot'
-        };
-        if (typeof options.content === 'string') {
-            mailOptions.text = options.content;
-        }
-        else if (Array.isArray(options.content)) {
-            const textParts = [];
-            const htmlParts = [];
-            const attachments = [];
-            for (const item of options.content) {
-                if (typeof item === 'string') {
-                    textParts.push(item);
-                    htmlParts.push(item.replace(/\n/g, '<br>'));
-                }
-                else {
-                    const segment = item;
-                    switch (segment.type) {
-                        case 'text':
-                            const textContent = segment.data.text || segment.data.content || '';
-                            textParts.push(textContent);
-                            htmlParts.push(textContent.replace(/\n/g, '<br>'));
-                            break;
-                        case 'image':
-                            if (segment.data.url) {
-                                attachments.push({
-                                    filename: segment.data.filename || 'image.png',
-                                    path: segment.data.url
-                                });
-                            }
-                            break;
-                        case 'file':
-                            if (segment.data.url) {
-                                attachments.push({
-                                    filename: segment.data.filename || 'file',
-                                    path: segment.data.url
-                                });
-                            }
-                            break;
-                    }
-                }
-            }
-            if (textParts.length > 0) {
-                mailOptions.text = textParts.join('\n');
-                mailOptions.html = htmlParts.join('<br>');
-            }
-            if (attachments.length > 0) {
-                mailOptions.attachments = attachments;
-            }
-        }
-        // 如果有回复对象，可以在这里处理
-        // 邮件适配器暂时不支持回复对象
-        return mailOptions;
-    }
-    // 下载附件到本地
-    async downloadAttachment(attachment) {
-        if (!this.$config.attachments?.enabled || !this.$config.attachments.downloadPath) {
-            throw new Error('Attachment download is not enabled');
-        }
-        const downloadPath = this.$config.attachments.downloadPath;
-        await fs.mkdir(downloadPath, { recursive: true });
-        const filename = attachment.filename || `attachment_${Date.now()}`;
-        const filepath = path.join(downloadPath, filename);
-        return new Promise((resolve, reject) => {
-            const writeStream = createWriteStream(filepath);
-            writeStream.write(attachment.content);
-            writeStream.end();
-            writeStream.on('finish', () => resolve(filepath));
-            writeStream.on('error', reject);
+        msg.once('end', () => {
+            void simpleParser(body).then((parsed) => {
+                this.admit(parseEmailMessage(parsed, uid));
+            }).catch((error) => {
+                logger.error('Error parsing email:', error);
+            });
         });
     }
-    /**
-     * HTML → 纯文本转换，处理常见标签和实体
-     */
-    static htmlToText(html) {
-        return htmlToPlainTextWithBlockBreaks(html);
-    }
 }
-// 创建和注册适配器
-//# sourceMappingURL=endpoint.js.map

package/lib/index.d.ts

@@ -1,10 +1,3 @@
-import { EmailAdapter } from "./adapter.js";
-declare module "zhin.js" {
-    interface Adapters {
-        email: EmailAdapter;
-    }
-}
-export * from "./types.js";
-export { EmailEndpoint } from "./endpoint.js";
-export { EmailAdapter } from "./adapter.js";
-//# sourceMappingURL=index.d.ts.map
+export { addressListText, formatInboundContent, formatOutboundMail, htmlToText, parseEmailMessage, resolveEmailConfig, senderDisplayName, type EmailAdapterConfig, type EmailAttachmentsConfig, type EmailMessage, type EmailWireSegment, type ImapConfig, type ResolvedEmailConfig, type SmtpConfig, } from './protocol.js';
+export { EmailEndpoint, type EmailEndpointOptions, } from './endpoint.js';
+export { defaultCreateImap, defaultCreateSmtp, type EmailImapFetchMessage, type EmailImapTransport, type EmailSmtpTransport, } from './transport.js';

package/lib/index.js

@@ -1,23 +1,3 @@
-/**
- * Email 适配器入口：类型扩展、导出、注册
- */
-import { usePlugin } from "zhin.js";
-import { EmailAdapter } from "./adapter.js";
-export * from "./types.js";
-export { EmailEndpoint } from "./endpoint.js";
-export { EmailAdapter } from "./adapter.js";
-const plugin = usePlugin();
-const { provide } = plugin;
-provide({
-    name: "email",
-    description: "Email Endpoint Adapter",
-    mounted: async (p) => {
-        const adapter = new EmailAdapter(p);
-        await adapter.start();
-        return adapter;
-    },
-    dispose: async (adapter) => {
-        await adapter.stop();
-    },
-});
-//# sourceMappingURL=index.js.map
+export { addressListText, formatInboundContent, formatOutboundMail, htmlToText, parseEmailMessage, resolveEmailConfig, senderDisplayName, } from './protocol.js';
+export { EmailEndpoint, } from './endpoint.js';
+export { defaultCreateImap, defaultCreateSmtp, } from './transport.js';