@lmcl/ailo-mcp-email 0.0.1

package/README.md

@@ -0,0 +1,45 @@
+# @lmcl/ailo-mcp-email
+
+Ailo 邮件通道 MCP：IMAP 收信 + SMTP 发信。
+
+## 配置
+
+| 变量 | 必填 | 说明 |
+|------|------|------|
+| IMAP_HOST | 是 | IMAP 服务器（如 imap.qq.com） |
+| IMAP_USER | 是 | 邮箱账号 |
+| IMAP_PASSWORD | 是 | 密码或授权码 |
+| IMAP_PORT | 否 | 默认 993 |
+| SMTP_HOST | 否 | 不填则从 IMAP 推测（如 smtp.qq.com） |
+| SMTP_PORT | 否 | 默认 465 |
+| SMTP_USER | 否 | 不填则用 IMAP_USER |
+| SMTP_PASSWORD | 否 | 不填则用 IMAP_PASSWORD |
+| TLS_REJECT_UNAUTHORIZED | 否 | 默认 true 验证证书；自签名可设为 false |
+
+## 在 Aido 中添加
+
+通过 `mcp_manage` 工具创建。**name 只能含字母、汉字、下划线**（无标点无数字），推荐纯英文尽量短：
+
+```
+mcp_manage(action=create, name="email", command="npx", args=["@lmcl/ailo-mcp-email"], env={IMAP_HOST: "imap.qq.com", IMAP_USER: "xxx", IMAP_PASSWORD: "xxx"})
+mcp_manage(action=start, name="email")
+```
+
+## 本地开发
+
+创建 `.env` 文件，填入配置后启动：
+
+```bash
+# .env 示例（必填：IMAP_HOST、IMAP_USER、IMAP_PASSWORD）
+IMAP_HOST=imap.qq.com
+IMAP_PORT=993
+IMAP_USER=your@email.com
+IMAP_PASSWORD=your_auth_code
+# SMTP_HOST=...
+# SMTP_PORT=465
+# TLS_REJECT_UNAUTHORIZED=false  # 自签名证书时
+
+npm install
+npm run build
+npm start
+```

package/dist/email-handler.js

@@ -0,0 +1,486 @@
+/**
+ * 邮件通道 Handler：IMAP 收信/读信/搜索/组织 + nodemailer 发信/回复/转发
+ */
+// @ts-nocheck
+import fs from "fs";
+import path from "path";
+import Imap from "imap";
+import { simpleParser } from "mailparser";
+import nodemailer from "nodemailer";
+import { getWorkDir } from "@lmcl/ailo-mcp-sdk";
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const parseHeader = require("imap/lib/Parser").parseHeader;
+function p(fn) {
+    return new Promise((resolve, reject) => {
+        fn((err, result) => (err ? reject(err) : resolve(result)));
+    });
+}
+function parseHeaderSafe(buf) {
+    try {
+        return parseHeader(buf);
+    }
+    catch {
+        return {};
+    }
+}
+export class EmailHandler {
+    config;
+    onMessageHandler = null;
+    imap = null;
+    transporter = null;
+    checkInterval = null;
+    lastUid = 0;
+    storage = null;
+    constructor(config) {
+        this.config = config;
+    }
+    setDataProvider(storage) {
+        this.storage = storage;
+    }
+    setOnMessage(handler) {
+        this.onMessageHandler = handler;
+    }
+    getSmtpHost() {
+        if (this.config.smtpHost)
+            return this.config.smtpHost;
+        const m = this.config.imapHost.match(/^imap\.(.+)$/);
+        return m ? `smtp.${m[1]}` : this.config.imapHost.replace("imap", "smtp");
+    }
+    getSmtpPort() {
+        return this.config.smtpPort ?? 465;
+    }
+    getSmtpUser() {
+        return this.config.smtpUser ?? this.config.imapUser;
+    }
+    getSmtpPassword() {
+        return this.config.smtpPassword ?? this.config.imapPassword;
+    }
+    ensureTransporter() {
+        if (!this.transporter) {
+            this.transporter = nodemailer.createTransport({
+                host: this.getSmtpHost(),
+                port: this.getSmtpPort(),
+                secure: this.getSmtpPort() === 465,
+                auth: { user: this.getSmtpUser(), pass: this.getSmtpPassword() },
+            });
+        }
+        return this.transporter;
+    }
+    withImap(folder, fn) {
+        return new Promise((resolve, reject) => {
+            if (!this.imap) {
+                reject(new Error("IMAP 未连接"));
+                return;
+            }
+            this.imap.openBox(folder, false, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                fn(this.imap).then(resolve).catch(reject);
+            });
+        });
+    }
+    async send(opts) {
+        const t = this.ensureTransporter();
+        await t.sendMail({
+            from: this.config.imapUser,
+            to: opts.to,
+            cc: opts.cc,
+            bcc: opts.bcc,
+            subject: opts.subject ?? "（无主题）",
+            text: opts.body,
+            html: opts.html,
+            attachments: opts.attachments?.map((a) => ({
+                filename: a.filename,
+                content: a.content,
+                contentType: a.contentType,
+            })),
+        });
+    }
+    async reply(opts) {
+        const detail = await this.read({ uid: opts.uid, folder: opts.folder });
+        if (!detail)
+            throw new Error(`邮件 uid=${opts.uid} 不存在`);
+        const orig = await this.fetchRaw(opts.uid, opts.folder ?? "INBOX");
+        if (!orig)
+            throw new Error(`无法获取原始邮件`);
+        const inReplyTo = orig.messageId;
+        const refs = orig.references;
+        const references = Array.isArray(refs) ? refs.join(" ") : refs ?? inReplyTo ?? "";
+        const to = orig.from?.value?.[0]?.address ?? "";
+        const subj = (orig.subject ?? "").startsWith("Re:") ? orig.subject : `Re: ${orig.subject ?? ""}`;
+        const t = this.ensureTransporter();
+        await t.sendMail({
+            from: this.config.imapUser,
+            to,
+            subject: subj,
+            text: opts.body,
+            html: opts.html,
+            attachments: opts.attachments?.map((a) => ({
+                filename: a.filename,
+                content: a.content,
+                contentType: a.contentType,
+            })),
+            inReplyTo,
+            references,
+        });
+    }
+    async forward(opts) {
+        const raw = await this.fetchRaw(opts.uid, opts.folder ?? "INBOX");
+        if (!raw)
+            throw new Error(`邮件 uid=${opts.uid} 不存在`);
+        const subj = (raw.subject ?? "").startsWith("Fwd:") ? raw.subject : `Fwd: ${raw.subject ?? ""}`;
+        const fwdText = raw.text ?? raw.html ?? "";
+        const t = this.ensureTransporter();
+        await t.sendMail({
+            from: this.config.imapUser,
+            to: opts.to,
+            cc: opts.cc,
+            bcc: opts.bcc,
+            subject: subj,
+            text: opts.body ? `${opts.body}\n\n--- 转发内容 ---\n${fwdText}` : fwdText,
+            html: opts.body ? `<p>${opts.body.replace(/\n/g, "<br>")}</p><hr>${raw.html ?? ""}` : raw.html,
+        });
+    }
+    async list(opts) {
+        const folder = opts.folder ?? "INBOX";
+        const limit = Math.max(1, Math.min(opts.limit ?? 50, 200));
+        const offset = Math.max(0, opts.offset ?? 0);
+        return this.withImap(folder, async (imap) => {
+            const criteria = opts.unreadOnly ? ["UNSEEN"] : ["ALL"];
+            const uids = await p((cb) => imap.search(criteria, cb));
+            if (uids.length === 0)
+                return [];
+            const sorted = uids.sort((a, b) => b - a);
+            const slice = sorted.slice(offset, offset + limit);
+            if (slice.length === 0)
+                return [];
+            const items = [];
+            return new Promise((resolve, reject) => {
+                const f = imap.fetch(slice, {
+                    bodies: "HEADER.FIELDS (FROM TO SUBJECT DATE)",
+                    struct: false,
+                });
+                f.on("message", (msg) => {
+                    let buf = "";
+                    let attrs = null;
+                    msg.on("body", (stream) => {
+                        stream.on("data", (ch) => {
+                            buf += ch.toString();
+                        });
+                    });
+                    msg.once("attributes", (a) => {
+                        attrs = a;
+                    });
+                    msg.on("end", () => {
+                        if (attrs && buf) {
+                            const h = parseHeaderSafe(buf);
+                            items.push({
+                                uid: attrs.uid,
+                                from: String(h.from?.[0] ?? ""),
+                                to: String(h.to?.[0] ?? ""),
+                                subject: String(h.subject?.[0] ?? "（无主题）"),
+                                date: String(h.date?.[0] ?? new Date()),
+                                isRead: (attrs.flags ?? []).includes("\\Seen"),
+                            });
+                        }
+                    });
+                });
+                f.once("error", reject);
+                f.on("end", () => resolve(items.sort((a, b) => b.uid - a.uid)));
+            });
+        });
+    }
+    async read(opts) {
+        const folder = opts.folder ?? "INBOX";
+        const raw = await this.fetchRaw(opts.uid, folder);
+        if (!raw)
+            return null;
+        const from = raw.from?.value?.[0];
+        const to = raw.to?.value?.map((v) => v.address).join(", ") ?? "";
+        const atts = raw.attachments ?? [];
+        return {
+            uid: opts.uid,
+            from: from ? `${from.name || ""} <${from.address}>`.trim() || (from.address ?? "") : "",
+            to,
+            subject: raw.subject ?? "（无主题）",
+            date: raw.date?.toISOString() ?? "",
+            text: raw.text ?? undefined,
+            html: raw.html ?? undefined,
+            attachments: atts.map((a) => ({
+                filename: a.filename ?? "attachment",
+                contentType: a.contentType ?? "application/octet-stream",
+                size: a.size ?? 0,
+            })),
+        };
+    }
+    async fetchRaw(uid, folder) {
+        return this.withImap(folder, (imap) => {
+            return new Promise((resolve, reject) => {
+                let resolved = false;
+                const doResolve = (v) => {
+                    if (!resolved) {
+                        resolved = true;
+                        resolve(v);
+                    }
+                };
+                const f = imap.fetch(uid, { bodies: "" });
+                f.on("message", (msg) => {
+                    msg.on("body", (stream) => {
+                        void simpleParser(stream)
+                            .then((mail) => doResolve(mail))
+                            .catch((e) => {
+                            if (!resolved) {
+                                resolved = true;
+                                reject(e);
+                            }
+                        });
+                    });
+                });
+                f.once("error", reject);
+                f.on("end", () => doResolve(null));
+            });
+        });
+    }
+    async search(opts) {
+        const folder = opts.folder ?? "INBOX";
+        const limit = Math.max(1, Math.min(opts.limit ?? 50, 200));
+        return this.withImap(folder, async (imap) => {
+            const criteria = [];
+            if (opts.from)
+                criteria.push(["FROM", opts.from]);
+            if (opts.to)
+                criteria.push(["TO", opts.to]);
+            if (opts.subject)
+                criteria.push(["SUBJECT", opts.subject]);
+            if (opts.since)
+                criteria.push(["SINCE", opts.since]);
+            if (opts.until)
+                criteria.push(["BEFORE", opts.until]);
+            if (opts.query)
+                criteria.push(["BODY", opts.query]);
+            if (criteria.length === 0)
+                criteria.push("ALL");
+            const uids = await p((cb) => imap.search(criteria, cb));
+            const sorted = uids.sort((a, b) => b - a).slice(0, limit);
+            if (sorted.length === 0)
+                return [];
+            const items = [];
+            return new Promise((resolve, reject) => {
+                const f = imap.fetch(sorted, {
+                    bodies: "HEADER.FIELDS (FROM TO SUBJECT DATE)",
+                    struct: false,
+                });
+                f.on("message", (msg) => {
+                    let buf = "";
+                    let attrs = null;
+                    msg.on("body", (stream) => {
+                        stream.on("data", (ch) => {
+                            buf += ch.toString();
+                        });
+                    });
+                    msg.once("attributes", (a) => {
+                        attrs = a;
+                    });
+                    msg.on("end", () => {
+                        if (attrs && buf) {
+                            const h = parseHeaderSafe(buf);
+                            items.push({
+                                uid: attrs.uid,
+                                from: String(h.from?.[0] ?? ""),
+                                to: String(h.to?.[0] ?? ""),
+                                subject: String(h.subject?.[0] ?? "（无主题）"),
+                                date: String(h.date?.[0] ?? new Date()),
+                                isRead: (attrs.flags ?? []).includes("\\Seen"),
+                            });
+                        }
+                    });
+                });
+                f.once("error", reject);
+                f.on("end", () => resolve(items.sort((a, b) => b.uid - a.uid)));
+            });
+        });
+    }
+    async markRead(opts) {
+        const uids = opts.uids.slice(0, 500);
+        if (uids.length === 0)
+            return;
+        const folder = opts.folder ?? "INBOX";
+        await this.withImap(folder, async (imap) => {
+            if (opts.read) {
+                await p((cb) => imap.addFlags(uids, "\\Seen", cb));
+            }
+            else {
+                await p((cb) => imap.delFlags(uids, "\\Seen", cb));
+            }
+        });
+    }
+    async move(opts) {
+        const uids = opts.uids.slice(0, 500);
+        if (uids.length === 0)
+            return;
+        const fromFolder = opts.fromFolder ?? "INBOX";
+        await this.withImap(fromFolder, async (imap) => {
+            await p((cb) => imap.move(uids, opts.folder, cb));
+        });
+    }
+    async delete(opts) {
+        const uids = opts.uids.slice(0, 500);
+        if (uids.length === 0)
+            return;
+        const folder = opts.folder ?? "INBOX";
+        await this.withImap(folder, async (imap) => {
+            await p((cb) => imap.addFlags(uids, "\\Deleted", cb));
+            await p((cb) => imap.expunge(cb));
+        });
+    }
+    async getAttachment(opts) {
+        const folder = opts.folder ?? "INBOX";
+        const raw = (await this.fetchRaw(opts.uid, folder));
+        if (!raw?.attachments?.length)
+            return null;
+        const att = raw.attachments.find((a) => (a.filename ?? "") === opts.filename);
+        if (!att?.content)
+            return null;
+        return typeof att.content === "string"
+            ? Buffer.from(att.content).toString("base64")
+            : att.content.toString("base64");
+    }
+    async sendText(to, text, subject) {
+        await this.send({ to, body: text, subject });
+    }
+    start() {
+        const imap = new Imap({
+            user: this.config.imapUser,
+            password: this.config.imapPassword,
+            host: this.config.imapHost,
+            port: this.config.imapPort,
+            tls: this.config.tls ?? true,
+            tlsOptions: { rejectUnauthorized: this.config.tlsRejectUnauthorized ?? true },
+        });
+        this.imap = imap;
+        const openInbox = (cb) => {
+            imap.openBox("INBOX", false, cb);
+        };
+        const fetchNew = () => {
+            if (!this.imap || !this.onMessageHandler)
+                return;
+            openInbox((err) => {
+                if (err) {
+                    console.error("[email] IMAP openBox failed:", err);
+                    return;
+                }
+                imap.search([["UID", `${this.lastUid + 1}:*`]], (searchErr, uids) => {
+                    if (searchErr || !uids?.length)
+                        return;
+                    const fetch = imap.fetch(uids, { bodies: "" });
+                    fetch.on("message", (msg) => {
+                        let uid = 0;
+                        msg.once("attributes", (attrs) => {
+                            uid = attrs.uid;
+                        });
+                        msg.on("body", (stream) => {
+                            void simpleParser(stream).then((parsed) => {
+                                if (parsed && uid) {
+                                    if (uid > this.lastUid)
+                                        this.lastUid = uid;
+                                    this.emitMessage(parsed);
+                                }
+                            });
+                        });
+                    });
+                    fetch.on("end", () => {
+                        this.storage?.setData("last_uid", String(this.lastUid)).catch(() => { });
+                    });
+                });
+            });
+        };
+        imap.once("ready", () => {
+            console.error("[email] IMAP connected to", this.config.imapHost);
+            this.storage?.getData("last_uid").then((v) => {
+                if (v)
+                    this.lastUid = parseInt(v, 10) || 0;
+                fetchNew();
+            });
+        });
+        imap.once("error", (err) => console.error("[email] IMAP error:", err));
+        imap.once("end", () => console.error("[email] IMAP connection ended"));
+        imap.connect();
+        this.checkInterval = setInterval(fetchNew, 60 * 1000);
+    }
+    async emitMessage(parsed) {
+        if (!parsed || !this.onMessageHandler)
+            return;
+        const from = parsed.from?.value?.[0];
+        const fromAddr = from?.address ?? "unknown";
+        const fromName = from?.name ?? fromAddr;
+        const subject = parsed.subject ?? "（无主题）";
+        const text = parsed.text ?? parsed.html ?? "";
+        const date = parsed.date ? parsed.date.getTime() : Date.now();
+        const attachments = await this.saveAttachmentsToWorkdir(parsed);
+        const d = new Date(date);
+        const pad = (n) => String(n).padStart(2, "0");
+        const contextTags = [
+            { desc: "类型", value: "私聊", core: true },
+            { desc: "会话", value: fromAddr, core: true },
+            { desc: "昵称", value: fromName, core: true },
+            { desc: "用户", value: fromAddr, core: true },
+            { desc: "时间", value: `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`, core: false },
+        ];
+        this.onMessageHandler({
+            text: `[主题: ${subject}]\n\n${text}`.trim(),
+            contextTags,
+            attachments: attachments.length > 0 ? attachments : undefined,
+        });
+    }
+    async saveAttachmentsToWorkdir(parsed) {
+        const rawAtts = parsed
+            .attachments;
+        if (!rawAtts?.length)
+            return [];
+        const workDir = getWorkDir();
+        const blobsDir = workDir ? path.join(workDir, "blobs") : null;
+        if (!blobsDir)
+            return [];
+        try {
+            await fs.promises.mkdir(blobsDir, { recursive: true });
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        const ts = Date.now();
+        for (let i = 0; i < rawAtts.length; i++) {
+            const a = rawAtts[i];
+            if (!a?.content || !Buffer.isBuffer(a.content))
+                continue;
+            const base = (a.filename ?? "attachment").replace(/[^a-zA-Z0-9._-]/g, "_") || "attachment";
+            const ext = path.extname(base) || "";
+            const stem = path.basename(base, ext) || "attachment";
+            const filename = `${stem}_${ts}_${i}${ext}`;
+            const outPath = path.join(blobsDir, filename);
+            try {
+                await fs.promises.writeFile(outPath, a.content);
+                const mime = a.contentType ?? "application/octet-stream";
+                const type = mime.startsWith("image/") ? "image" : mime.startsWith("audio/") ? "audio" : mime.startsWith("video/") ? "video" : "file";
+                out.push({ type, path: outPath, mime, name: a.filename ?? filename });
+            }
+            catch {
+                // 落盘失败则跳过该附件
+            }
+        }
+        return out;
+    }
+    stop() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+        if (this.imap) {
+            this.imap.end();
+            this.imap = null;
+        }
+        this.transporter = null;
+    }
+}

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { runMcpChannel } from "@lmcl/ailo-mcp-sdk";
+import "dotenv/config";
+import { EmailHandler } from "./email-handler.js";
+import { createEmailMcpServer } from "./mcp-server.js";
+const IMAP_HOST = process.env.IMAP_HOST ?? "";
+const IMAP_USER = process.env.IMAP_USER ?? "";
+const IMAP_PASSWORD = process.env.IMAP_PASSWORD ?? "";
+const IMAP_PORT = parseInt(process.env.IMAP_PORT ?? "993", 10);
+if (!IMAP_HOST || !IMAP_USER || !IMAP_PASSWORD) {
+    console.error("Missing IMAP_HOST, IMAP_USER or IMAP_PASSWORD");
+    process.exit(1);
+}
+const handler = new EmailHandler({
+    imapHost: IMAP_HOST,
+    imapPort: IMAP_PORT,
+    imapUser: IMAP_USER,
+    imapPassword: IMAP_PASSWORD,
+    smtpHost: process.env.SMTP_HOST || undefined,
+    smtpPort: process.env.SMTP_PORT ? parseInt(process.env.SMTP_PORT, 10) : undefined,
+    smtpUser: process.env.SMTP_USER || undefined,
+    smtpPassword: process.env.SMTP_PASSWORD || undefined,
+    tlsRejectUnauthorized: process.env.TLS_REJECT_UNAUTHORIZED !== "false",
+});
+function emailBuildChannelPrompt() {
+    return `邮件通道：chat_id 为发件人邮箱地址。回复时使用 email 工具（action=send），to 填对方邮箱。`;
+}
+const mcpServer = createEmailMcpServer(handler);
+runMcpChannel({
+    handler,
+    buildChannelPrompt: emailBuildChannelPrompt,
+    mcpServer,
+});