@zhin.js/adapter-email 0.1.39 → 0.1.40

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @zhin.js/adapter-email
 
+## 0.1.40
+
+### Patch Changes
+
+- Updated dependencies [bb6bfa8]
+- Updated dependencies [bb6bfa8]
+  - zhin.js@1.0.52
+
 ## 0.1.39
 
 ### Patch Changes

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@zhin.js/adapter-email",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "Zhin.js adapter for Email (SMTP/IMAP)",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "dependencies": {
     "@types/imap": "^0.8.40",
     "@types/nodemailer": "^6.4.14",
@@ -13,13 +13,13 @@
     "nodemailer": "^7.0.11"
   },
   "peerDependencies": {
-    "zhin.js": "1.0.51"
+    "zhin.js": "1.0.52"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6",
     "@types/node": "^20.10.6",
     "typescript": "^5.3.3",
-    "zhin.js": "1.0.51"
+    "zhin.js": "1.0.52"
   },
   "keywords": [
     "zhin",
@@ -42,9 +42,13 @@
     "directory": "plugins/adapters/email"
   },
   "files": [
+    "src",
     "lib",
-    "node",
+    "client",
+    "dist",
+    "skills",
     "README.md",
+    "node",
     "CHANGELOG.md"
   ],
   "publishConfig": {

package/src/adapter.ts

@@ -0,0 +1,16 @@
+/**
+ * Email 适配器
+ */
+import { Adapter, Plugin } from "zhin.js";
+import { EmailBot } from "./bot.js";
+import type { EmailBotConfig } from "./types.js";
+
+export class EmailAdapter extends Adapter<EmailBot> {
+    constructor(plugin: Plugin) {
+        super(plugin, 'email', []);
+    }
+
+    createBot(config: EmailBotConfig): EmailBot {
+        return new EmailBot(this, config);
+    }
+}

package/src/bot.ts

@@ -0,0 +1,422 @@
+/**
+ * Email Bot 实现
+ */
+import nodemailer from "nodemailer";
+import Imap from "imap";
+import { simpleParser, type ParsedMail, type Attachment } from "mailparser";
+import { Bot, Message, SendOptions, SendContent, MessageSegment, segment } from "zhin.js";
+import { EventEmitter } from "events";
+import { createWriteStream, promises as fs } from "fs";
+import path from "path";
+import type { EmailBotConfig, EmailMessage } from "./types.js";
+import type { EmailAdapter } from "./adapter.js";
+
+export class EmailBot extends EventEmitter implements Bot<EmailBotConfig, EmailMessage> {
+    $config: EmailBotConfig;
+    $connected: boolean = false;
+    private smtpTransporter: nodemailer.Transporter | null = null;
+    private imapConnection: Imap | null = null;
+    private checkTimer: NodeJS.Timeout | null = null;
+
+    get logger() {
+    return this.adapter.plugin.logger;
+  }
+
+  get $id() {
+        return this.$config.name;
+    }
+
+    constructor(public adapter: EmailAdapter, config: EmailBotConfig) {
+        super();
+        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(): Promise<void> {
+        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.info(`SMTP connection verified for ${this.$config.smtp.auth.user}`);
+
+            // 初始化 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
+            await new Promise<void>((resolve, reject) => {
+                this.imapConnection!.once('ready', resolve);
+                this.imapConnection!.once('error', reject);
+                this.imapConnection!.connect();
+            });
+
+            this.logger.info(`IMAP connection established for ${this.$config.imap.user}`);
+
+            // 开始检查邮件
+            this.startEmailCheck();
+            this.$connected = true;
+
+        } catch (error) {
+            this.logger.error('Failed to connect email services:', error);
+            throw error;
+        }
+    }
+
+    async $disconnect(): Promise<void> {
+        this.$connected = false;
+
+        // 停止定时检查
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+
+        // 关闭 IMAP 连接
+        if (this.imapConnection) {
+            this.imapConnection.end();
+            this.imapConnection = null;
+        }
+
+        // 关闭 SMTP 连接
+        if (this.smtpTransporter) {
+            this.smtpTransporter.close();
+            this.smtpTransporter = null;
+        }
+
+        this.logger.info('Email bot disconnected');
+    }
+
+    private setupImapListeners(): void {
+        if (!this.imapConnection) return;
+
+        this.imapConnection.on('mail', (numNewMsgs: number) => {
+            this.logger.debug(`Received ${numNewMsgs} new emails`);
+            this.checkForNewEmails();
+        });
+
+        this.imapConnection.on('error', (error: any) => {
+            this.logger.error('IMAP error:', error);
+        });
+
+        this.imapConnection.on('end', () => {
+            this.logger.info('IMAP connection ended');
+        });
+    }
+
+    private startEmailCheck(): void {
+        if (this.checkTimer) return;
+
+        this.checkTimer = setInterval(() => {
+            this.checkForNewEmails();
+        }, this.$config.imap.checkInterval!);
+
+        // 立即检查一次
+        this.checkForNewEmails();
+    }
+
+    private async checkForNewEmails(): Promise<void> {
+        if (!this.imapConnection || !this.$connected) return;
+
+        try {
+            await new Promise<void>((resolve, reject) => {
+                this.imapConnection!.openBox(this.$config.imap.mailbox!, false, (error, box) => {
+                    if (error) return reject(error);
+
+                    // 搜索未读邮件
+                    this.imapConnection!.search(['UNSEEN'], (error, results) => {
+                        if (error) return reject(error);
+
+                        if (results.length === 0) {
+                            return resolve();
+                        }
+
+                        // 获取邮件
+                        const fetch = this.imapConnection!.fetch(results, {
+                            bodies: '',
+                            markSeen: this.$config.imap.markSeen
+                        });
+
+                        fetch.on('message', (msg, seqno) => {
+                            this.handleImapMessage(msg, seqno);
+                        });
+
+                        fetch.once('error', reject);
+                        fetch.once('end', resolve);
+                    });
+                });
+            });
+        } catch (error) {
+            this.logger.error('Error checking for new emails:', error);
+        }
+    }
+
+    private handleImapMessage(msg: any, seqno: number): void {
+        let body = '';
+        let uid = 0;
+
+        msg.on('body', (stream: any) => {
+            stream.on('data', (chunk: any) => {
+                body += chunk.toString('utf8');
+            });
+        });
+
+        msg.once('attributes', (attrs: any) => {
+            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);
+            }
+        });
+    }
+
+    private parseEmailMessage(parsed: ParsedMail, uid: number): EmailMessage {
+        const getAddressText = (addr: any): string[] => {
+            if (!addr) return [];
+            if (Array.isArray(addr)) {
+                return addr.map((a: any) => 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: EmailMessage): Message<EmailMessage> {
+        // 确定频道类型和ID
+        const channelType = 'private';
+        const channelId = emailMsg.from;
+
+        // 解析邮件内容
+        const content = EmailBot.parseEmailContent(emailMsg);
+
+        const result = Message.from(emailMsg, {
+            $id: emailMsg.messageId,
+            $adapter: 'email',
+            $bot: this.$config.name,
+            $sender: {
+                id: emailMsg.from,
+                name: emailMsg.from.split('<')[0].trim() || emailMsg.from
+            },
+            $channel: {
+                id: channelId,
+                type: channelType as any
+            },
+            $raw: JSON.stringify(emailMsg),
+            $timestamp: emailMsg.date.getTime(),
+            $content: content,
+            $recall: async () => {
+                // 邮件适配器暂时不支持撤回消息
+            },
+            $reply: async (content: SendContent): Promise<string> => {
+                return await this.adapter.sendMessage({
+                    context: this.$config.context,
+                    bot: this.$config.name,
+                    id: emailMsg.from,
+                    type: 'private',
+                    content
+                });
+            }
+        });
+
+        return result;
+    }
+
+    static parseEmailContent(email: EmailMessage): MessageSegment[] {
+        const segments: MessageSegment[] = [];
+
+        // 添加主题（如果有且不为空）
+        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) {
+            // 简单的HTML到文本转换
+            const textFromHtml = email.html
+                .replace(/<[^>]*>/g, '') // 移除HTML标签
+                .replace(/&nbsp;/g, ' ')
+                .replace(/&amp;/g, '&')
+                .replace(/&lt;/g, '<')
+                .replace(/&gt;/g, '>')
+                .replace(/&quot;/g, '"')
+                .trim();
+
+            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: SendOptions): Promise<string> {
+        if (!this.smtpTransporter) {
+            throw new Error('SMTP transporter not initialized');
+        }
+
+        try {
+            const mailOptions = await this.formatSendContent(options);
+            const info = await this.smtpTransporter.sendMail(mailOptions);
+            this.logger.debug('Email sent:', info.messageId);
+        } catch (error) {
+            this.logger.error('Failed to send email:', error);
+            throw error;
+        }
+        return ''
+    }
+
+    async $recallMessage(id: string): Promise<void> {
+        // 邮件适配器暂时不支持撤回消息
+    }
+
+    private async formatSendContent(options: SendOptions): Promise<nodemailer.SendMailOptions> {
+        const mailOptions: nodemailer.SendMailOptions = {
+            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: string[] = [];
+            const htmlParts: string[] = [];
+            const attachments: any[] = [];
+
+            for (const item of options.content) {
+                if (typeof item === 'string') {
+                    textParts.push(item);
+                    htmlParts.push(item.replace(/\n/g, '<br>'));
+                } else {
+                    const segment = item as MessageSegment;
+                    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;
+    }
+
+    // 下载附件到本地
+    private async downloadAttachment(attachment: Attachment): Promise<string> {
+        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);
+        });
+    }
+}
+
+// 创建和注册适配器

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Email 适配器入口：类型扩展、导出、注册
+ */
+import { usePlugin, type Plugin, type Context } from "zhin.js";
+import { EmailAdapter } from "./adapter.js";
+
+declare module "zhin.js" {
+  interface Adapters {
+    email: EmailAdapter;
+  }
+}
+
+export * from "./types.js";
+export { EmailBot } from "./bot.js";
+export { EmailAdapter } from "./adapter.js";
+
+const plugin = usePlugin();
+const { provide } = plugin;
+
+provide({
+  name: "email",
+  description: "Email Bot Adapter",
+  mounted: async (p: Plugin) => {
+    const adapter = new EmailAdapter(p);
+    await adapter.start();
+    return adapter;
+  },
+  dispose: async (adapter: EmailAdapter) => {
+    await adapter.stop();
+  },
+} as Context<"email">);

package/src/types.ts

@@ -0,0 +1,52 @@
+/**
+ * Email 适配器类型定义
+ */
+import type { Attachment } from "mailparser";
+
+export interface SmtpConfig {
+  host: string;
+  port: number;
+  secure: boolean;
+  auth: {
+    user: string;
+    pass: string;
+  };
+}
+
+export interface ImapConfig {
+  host: string;
+  port: number;
+  tls: boolean;
+  user: string;
+  password: string;
+  checkInterval?: number;
+  mailbox?: string;
+  markSeen?: boolean;
+}
+
+export interface EmailBotConfig {
+  context: "email";
+  name: string;
+  smtp: SmtpConfig;
+  imap: ImapConfig;
+  attachments?: {
+    enabled: boolean;
+    downloadPath?: string;
+    maxFileSize?: number;
+    allowedTypes?: string[];
+  };
+}
+
+export interface EmailMessage {
+  messageId: string;
+  from: string;
+  to: string[];
+  cc?: string[];
+  bcc?: string[];
+  subject: string;
+  text?: string;
+  html?: string;
+  attachments: Attachment[];
+  date: Date;
+  uid: number;
+}