@greatlhd/ailo-desktop 1.0.0

package/dist/email_handler.js

@@ -0,0 +1,501 @@
+/**
+ * 邮件通道 — IMAP IDLE 收信 + nodemailer SMTP 发信
+ *
+ * 集成在 Desktop 端点中，与 webchat 等通道共享同一 EndpointContext。
+ * IMAP IDLE 实现零延迟推送，断线自动重连，UIDVALIDITY 追踪。
+ */
+import { ImapFlow } from "imapflow";
+import { simpleParser } from "mailparser";
+import nodemailer from "nodemailer";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { textPart, mediaPart, classifyMedia, getWorkDir } from "@lmcl/ailo-endpoint-sdk";
+import { errMsg } from "./utils.js";
+import { NO_SUBJECT } from "./constants.js";
+function formatAddress(addr) {
+    if (!addr)
+        return "";
+    return `${addr.name ?? ""} <${addr.address ?? ""}>`.trim();
+}
+function formatToAddresses(to) {
+    if (!to)
+        return "";
+    return (Array.isArray(to) ? to : [to]).flatMap((t) => t.value.map((v) => v.address)).filter(Boolean).join(", ");
+}
+function mapAttachments(attachments) {
+    return attachments?.map((a) => ({
+        filename: a.filename,
+        content: a.content,
+        contentType: a.contentType,
+    }));
+}
+const RECONNECT_BASE_MS = 2_000;
+const RECONNECT_MAX_MS = 60_000;
+export class EmailHandler {
+    config;
+    ctx = null;
+    imap = null;
+    transporter = null;
+    stopped = false;
+    lastUid = 0;
+    uidValidity = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    async start(ctx) {
+        this.ctx = ctx;
+        this.stopped = false;
+        this.imapLoop().catch((err) => console.error("[email] imapLoop fatal:", err));
+        console.log("[email] 邮件通道已启动");
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.imap) {
+            try {
+                this.imap.close();
+            }
+            catch { /* ignore */ }
+            this.imap = null;
+        }
+        this.transporter = null;
+        this.ctx = null;
+        console.log("[email] 邮件通道已停止");
+    }
+    get running() {
+        return !this.stopped && this.ctx !== null;
+    }
+    // ── IMAP 连接/IDLE 主循环 ──
+    async imapLoop() {
+        let attempt = 0;
+        while (!this.stopped) {
+            try {
+                await this.connectImap();
+                attempt = 0;
+                await this.idleLoop();
+            }
+            catch (err) {
+                if (this.stopped)
+                    break;
+                console.error("[email] IMAP error:", errMsg(err));
+            }
+            if (this.stopped)
+                break;
+            const delay = Math.min(RECONNECT_BASE_MS * 2 ** attempt, RECONNECT_MAX_MS);
+            attempt++;
+            console.error(`[email] IMAP reconnecting in ${delay}ms (attempt ${attempt})`);
+            await sleep(delay);
+        }
+    }
+    async connectImap() {
+        if (this.imap) {
+            try {
+                this.imap.close();
+            }
+            catch { /* ignore */ }
+            this.imap = null;
+        }
+        this.imap = new ImapFlow({
+            host: this.config.imapHost,
+            port: this.config.imapPort,
+            auth: { user: this.config.imapUser, pass: this.config.imapPassword },
+            secure: true,
+            tls: { rejectUnauthorized: false },
+            logger: false,
+        });
+        await this.imap.connect();
+        console.log(`[email] IMAP connected to ${this.config.imapHost}`);
+        await this.restoreCheckpoint();
+    }
+    async idleLoop() {
+        while (this.imap?.usable && !this.stopped) {
+            const lock = await this.imap.getMailboxLock("INBOX");
+            try {
+                const box = this.imap.mailbox;
+                const validity = box ? Number(box.uidValidity ?? 0) : 0;
+                if (validity && validity !== this.uidValidity) {
+                    if (this.uidValidity !== 0) {
+                        console.log(`[email] UIDVALIDITY changed (${this.uidValidity} → ${validity}), resetting`);
+                    }
+                    this.uidValidity = validity;
+                    this.lastUid = 0;
+                }
+                await this.fetchNewMessages();
+            }
+            finally {
+                lock.release();
+            }
+            try {
+                await this.imap.idle();
+            }
+            catch {
+                // IDLE interrupted — loop back
+            }
+        }
+    }
+    async fetchNewMessages() {
+        if (!this.imap?.usable || !this.ctx)
+            return;
+        const range = `${this.lastUid + 1}:*`;
+        let maxUid = this.lastUid;
+        let count = 0;
+        try {
+            for await (const msg of this.imap.fetch(range, { uid: true, source: true }, { uid: true })) {
+                if (!msg || msg.uid <= this.lastUid)
+                    continue;
+                if (msg.uid > maxUid)
+                    maxUid = msg.uid;
+                if (!msg.source)
+                    continue;
+                count++;
+                try {
+                    const parsed = await simpleParser(msg.source);
+                    await this.emitMessage(parsed);
+                }
+                catch (err) {
+                    console.error(`[email] parse uid=${msg.uid} failed:`, errMsg(err));
+                }
+            }
+        }
+        catch (err) {
+            console.error("[email] fetch error:", errMsg(err));
+        }
+        if (maxUid > this.lastUid) {
+            this.lastUid = maxUid;
+            await this.saveCheckpoint();
+            if (count > 0)
+                console.log(`[email] processed ${count} new message(s), lastUid=${this.lastUid}`);
+        }
+    }
+    // ── Checkpoint 持久化 ──
+    async saveCheckpoint() {
+        if (!this.ctx)
+            return;
+        const cp = { lastUid: this.lastUid, uidValidity: this.uidValidity };
+        try {
+            await this.ctx.storage.setData("email_checkpoint", JSON.stringify(cp));
+        }
+        catch (err) {
+            console.error("[email] save checkpoint failed:", errMsg(err));
+        }
+    }
+    async restoreCheckpoint() {
+        if (!this.ctx)
+            return;
+        try {
+            const raw = await this.ctx.storage.getData("email_checkpoint");
+            if (!raw)
+                return;
+            const cp = JSON.parse(raw);
+            this.lastUid = cp.lastUid ?? 0;
+            this.uidValidity = cp.uidValidity ?? 0;
+            console.log(`[email] restored checkpoint: lastUid=${this.lastUid}, uidValidity=${this.uidValidity}`);
+        }
+        catch (err) {
+            console.error("[email] restore checkpoint failed:", errMsg(err));
+        }
+    }
+    // ── 收信推送 ──
+    async emitMessage(parsed) {
+        if (!this.ctx)
+            return;
+        const from = parsed.from?.value?.[0];
+        const fromAddr = from?.address ?? "unknown";
+        const fromName = from?.name ?? fromAddr;
+        const subject = parsed.subject ?? NO_SUBJECT;
+        const text = parsed.text ?? (typeof parsed.html === "string" ? parsed.html : "") ?? "";
+        const attachments = await this.saveAttachments(parsed);
+        const contextTags = [
+            { kind: "channel", value: "email", groupWith: true },
+            { kind: "conv_type", value: "私聊", groupWith: true },
+            { kind: "chat_id", value: fromAddr, groupWith: true, passToTool: true },
+            { kind: "participant", value: fromName, groupWith: false },
+            { kind: "sender_id", value: fromAddr, groupWith: false, passToTool: true },
+        ];
+        const content = [];
+        const bodyText = `[邮件 · 主题: ${subject}]\n\n${text}`.trim();
+        if (bodyText)
+            content.push(textPart(bodyText));
+        for (const a of attachments) {
+            const mediaType = classifyMedia(a.mime ?? "application/octet-stream");
+            content.push(mediaPart(mediaType, { type: mediaType, path: a.path, mime: a.mime, name: a.name }));
+        }
+        try {
+            await this.ctx.accept({ content, contextTags });
+        }
+        catch (err) {
+            console.error("[email] accept failed:", errMsg(err));
+        }
+    }
+    // ── IMAP 工具操作 ──
+    async withMailbox(folder, fn) {
+        if (!this.imap?.usable)
+            throw new Error("IMAP 未连接");
+        const lock = await this.imap.getMailboxLock(folder);
+        try {
+            return await fn(this.imap);
+        }
+        finally {
+            lock.release();
+        }
+    }
+    async list(opts) {
+        const folder = opts.folder ?? "INBOX";
+        const limit = clamp(opts.limit ?? 50, 1, 200);
+        const offset = Math.max(0, opts.offset ?? 0);
+        return this.withMailbox(folder, async (imap) => {
+            const criteria = opts.unreadOnly ? { seen: false } : {};
+            const result = await imap.search(criteria, { uid: true });
+            const uids = Array.isArray(result) ? result : [];
+            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 = [];
+            for await (const msg of imap.fetch(slice.join(","), { uid: true, envelope: true, flags: true }, { uid: true })) {
+                items.push({
+                    uid: msg.uid,
+                    from: formatAddress(msg.envelope?.from?.[0]),
+                    to: msg.envelope?.to?.map((a) => a.address).filter(Boolean).join(", ") ?? "",
+                    subject: msg.envelope?.subject ?? NO_SUBJECT,
+                    date: msg.envelope?.date?.toISOString() ?? "",
+                    isRead: msg.flags?.has("\\Seen") ?? false,
+                });
+            }
+            return items.sort((a, b) => b.uid - a.uid);
+        });
+    }
+    async read(opts) {
+        const folder = opts.folder ?? "INBOX";
+        return this.withMailbox(folder, async (imap) => {
+            let raw;
+            try {
+                raw = await imap.fetchOne(String(opts.uid), { uid: true, source: true }, { uid: true });
+            }
+            catch {
+                return null;
+            }
+            if (!raw || !raw.source)
+                return null;
+            const parsed = await simpleParser(raw.source);
+            await imap.messageFlagsAdd(String(opts.uid), ["\\Seen"], { uid: true }).catch(() => { });
+            return {
+                uid: opts.uid,
+                from: formatAddress(parsed.from?.value?.[0]),
+                to: formatToAddresses(parsed.to),
+                subject: parsed.subject ?? NO_SUBJECT,
+                date: parsed.date?.toISOString() ?? "",
+                text: parsed.text ?? undefined,
+                html: typeof parsed.html === "string" ? parsed.html : undefined,
+                attachments: (parsed.attachments ?? []).map((a) => ({
+                    filename: a.filename ?? "attachment",
+                    contentType: a.contentType ?? "application/octet-stream",
+                    size: a.size ?? 0,
+                })),
+            };
+        });
+    }
+    async search(opts) {
+        const folder = opts.folder ?? "INBOX";
+        const limit = clamp(opts.limit ?? 50, 1, 200);
+        return this.withMailbox(folder, async (imap) => {
+            const criteria = {};
+            if (opts.from)
+                criteria.from = opts.from;
+            if (opts.to)
+                criteria.to = opts.to;
+            if (opts.subject)
+                criteria.subject = opts.subject;
+            if (opts.since)
+                criteria.since = new Date(opts.since);
+            if (opts.until)
+                criteria.before = new Date(opts.until);
+            if (opts.query)
+                criteria.body = opts.query;
+            const result = await imap.search(criteria, { uid: true });
+            const uids = Array.isArray(result) ? result : [];
+            const sorted = [...uids].sort((a, b) => b - a).slice(0, limit);
+            if (sorted.length === 0)
+                return [];
+            const items = [];
+            for await (const msg of imap.fetch(sorted.join(","), { uid: true, envelope: true, flags: true }, { uid: true })) {
+                items.push({
+                    uid: msg.uid,
+                    from: formatAddress(msg.envelope?.from?.[0]),
+                    to: msg.envelope?.to?.map((a) => a.address).filter(Boolean).join(", ") ?? "",
+                    subject: msg.envelope?.subject ?? NO_SUBJECT,
+                    date: msg.envelope?.date?.toISOString() ?? "",
+                    isRead: msg.flags?.has("\\Seen") ?? false,
+                });
+            }
+            return items.sort((a, b) => b.uid - a.uid);
+        });
+    }
+    async markRead(opts) {
+        const uids = opts.uids.slice(0, 500);
+        if (uids.length === 0)
+            return;
+        await this.withMailbox(opts.folder ?? "INBOX", async (imap) => {
+            const range = uids.join(",");
+            if (opts.read)
+                await imap.messageFlagsAdd(range, ["\\Seen"], { uid: true });
+            else
+                await imap.messageFlagsRemove(range, ["\\Seen"], { uid: true });
+        });
+    }
+    async move(opts) {
+        const uids = opts.uids.slice(0, 500);
+        if (uids.length === 0)
+            return;
+        await this.withMailbox(opts.fromFolder ?? "INBOX", async (imap) => {
+            await imap.messageMove(uids.join(","), opts.folder, { uid: true });
+        });
+    }
+    async deleteMessages(opts) {
+        const uids = opts.uids.slice(0, 500);
+        if (uids.length === 0)
+            return;
+        await this.withMailbox(opts.folder ?? "INBOX", async (imap) => {
+            await imap.messageDelete(uids.join(","), { uid: true });
+        });
+    }
+    async downloadAttachment(opts) {
+        return this.withMailbox(opts.folder ?? "INBOX", async (imap) => {
+            let raw;
+            try {
+                raw = await imap.fetchOne(String(opts.uid), { uid: true, source: true }, { uid: true });
+            }
+            catch {
+                return null;
+            }
+            if (!raw || !raw.source)
+                return null;
+            const parsed = await simpleParser(raw.source);
+            const att = parsed.attachments?.find((a) => (a.filename ?? "") === opts.filename);
+            if (!att?.content || !Buffer.isBuffer(att.content))
+                return null;
+            const outDir = path.join(getWorkDir() ?? os.tmpdir(), "blobs");
+            await fs.promises.mkdir(outDir, { recursive: true });
+            const safeName = (att.filename ?? "attachment").replace(/[^a-zA-Z0-9._-]/g, "_");
+            const outPath = path.join(outDir, `${Date.now()}_${safeName}`);
+            await fs.promises.writeFile(outPath, att.content);
+            return outPath;
+        });
+    }
+    // ── SMTP 发信 ──
+    ensureTransporter() {
+        if (!this.transporter) {
+            const host = this.config.smtpHost ?? this.config.imapHost.replace(/^imap\./, "smtp.");
+            const port = this.config.smtpPort ?? 465;
+            const user = this.config.smtpUser ?? this.config.imapUser;
+            const pass = this.config.smtpPassword ?? this.config.imapPassword;
+            this.transporter = nodemailer.createTransport({
+                host,
+                port,
+                secure: port === 465,
+                auth: { user, pass },
+            });
+        }
+        return this.transporter;
+    }
+    async send(opts) {
+        await this.ensureTransporter().sendMail({
+            from: this.config.imapUser,
+            to: opts.to,
+            cc: opts.cc,
+            bcc: opts.bcc,
+            subject: opts.subject ?? NO_SUBJECT,
+            text: opts.body,
+            html: opts.html,
+            attachments: mapAttachments(opts.attachments),
+        });
+    }
+    async reply(opts) {
+        const parsed = await this.withMailbox(opts.folder ?? "INBOX", async (imap) => {
+            const raw = await imap.fetchOne(String(opts.uid), { uid: true, source: true }, { uid: true });
+            if (!raw || !raw.source)
+                throw new Error(`邮件 uid=${opts.uid} 不存在`);
+            return simpleParser(raw.source);
+        });
+        const to = parsed.from?.value?.[0]?.address ?? "";
+        const subj = parsed.subject?.startsWith("Re:") ? parsed.subject : `Re: ${parsed.subject ?? ""}`;
+        const refs = Array.isArray(parsed.references)
+            ? parsed.references.join(" ")
+            : (parsed.references ?? parsed.messageId ?? "");
+        await this.ensureTransporter().sendMail({
+            from: this.config.imapUser,
+            to,
+            subject: subj,
+            text: opts.body,
+            html: opts.html,
+            inReplyTo: parsed.messageId,
+            references: refs,
+            attachments: mapAttachments(opts.attachments),
+        });
+    }
+    async forward(opts) {
+        const parsed = await this.withMailbox(opts.folder ?? "INBOX", async (imap) => {
+            const raw = await imap.fetchOne(String(opts.uid), { uid: true, source: true }, { uid: true });
+            if (!raw || !raw.source)
+                throw new Error(`邮件 uid=${opts.uid} 不存在`);
+            return simpleParser(raw.source);
+        });
+        const subj = parsed.subject?.startsWith("Fwd:") ? parsed.subject : `Fwd: ${parsed.subject ?? ""}`;
+        const fwdText = parsed.text ?? (typeof parsed.html === "string" ? parsed.html : "");
+        await this.ensureTransporter().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>${typeof parsed.html === "string" ? parsed.html : ""}`
+                : (typeof parsed.html === "string" ? parsed.html : undefined),
+        });
+    }
+    // ── 内部工具 ──
+    async saveAttachments(parsed) {
+        if (!parsed.attachments?.length)
+            return [];
+        const workDir = getWorkDir();
+        if (!workDir)
+            return [];
+        const blobsDir = path.join(workDir, "blobs");
+        try {
+            await fs.promises.mkdir(blobsDir, { recursive: true });
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        const ts = Date.now();
+        for (let i = 0; i < parsed.attachments.length; i++) {
+            const a = parsed.attachments[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";
+                out.push({ type: classifyMedia(mime), path: outPath, mime, name: a.filename ?? filename });
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return out;
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function clamp(n, min, max) {
+    return Math.max(min, Math.min(max, n));
+}

package/dist/exec_tool.js

@@ -0,0 +1,90 @@
+import { spawn } from "child_process";
+import * as os from "os";
+import * as path from "path";
+import { mkdtemp, rm } from "fs/promises";
+const MAX_OUTPUT = 50000;
+const DEFAULT_TIMEOUT_MS = 120_000; // 2 分钟
+/**
+ * 异步执行 shell 命令。
+ * 立即返回"已启动"，命令在后台运行，完成后通过 sendSignal("tool_result") 推送结果给 LLM。
+ */
+export async function execTool(ctx, args) {
+    const command = String(args.command ?? "").trim();
+    if (!command)
+        throw new Error("command 必填");
+    const cwd = args.cwd || undefined;
+    const timeoutSec = Math.max(5, Math.min(600, Number(args.timeout) || DEFAULT_TIMEOUT_MS / 1000));
+    const timeoutMs = timeoutSec * 1000;
+    const isWin = os.platform() === "win32";
+    const shell = isWin ? "powershell" : "/bin/sh";
+    const wrappedCommand = isWin
+        ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${command}`
+        : command;
+    const shellArgs = isWin ? ["-Command", wrappedCommand] : ["-c", command];
+    const env = {
+        ...process.env,
+        PYTHONIOENCODING: "utf-8",
+        PYTHONUTF8: "1",
+    };
+    // 在临时目录执行命令，避免 cwd 污染
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), "ailo-exec-"));
+    const proc = spawn(shell, shellArgs, { stdio: ["pipe", "pipe", "pipe"], cwd: cwd || tmpDir, env });
+    const output = [];
+    let sent = false;
+    const cleanup = () => {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = null;
+        }
+        rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    };
+    const sendResult = (content) => {
+        if (sent)
+            return;
+        sent = true;
+        ctx.sendSignal("tool_result", { content });
+        cleanup();
+    };
+    let timeoutHandle = setTimeout(() => {
+        timeoutHandle = null;
+        try {
+            proc.kill("SIGTERM");
+        }
+        catch { }
+        setTimeout(() => { try {
+            proc.kill("SIGKILL");
+        }
+        catch { } }, 2000);
+        sendResult(JSON.stringify({
+            ok: false,
+            type: "timeout",
+            command,
+            timeoutSec: timeoutMs / 1000,
+            message: `超过 ${timeoutMs / 1000}s 未完成，已终止`,
+        }));
+    }, timeoutMs);
+    proc.stdout?.on("data", (d) => output.push(d.toString("utf-8")));
+    proc.stderr?.on("data", (d) => output.push(d.toString("utf-8")));
+    proc.on("close", (code) => {
+        const text = output.join("").trim();
+        const truncated = text.length > MAX_OUTPUT
+            ? text.slice(0, MAX_OUTPUT / 2) + "\n...[截断]...\n" + text.slice(-MAX_OUTPUT / 2)
+            : text;
+        sendResult(JSON.stringify({
+            ok: true,
+            type: "completed",
+            command,
+            exitCode: code,
+            output: truncated,
+        }));
+    });
+    proc.on("error", (err) => {
+        sendResult(JSON.stringify({
+            ok: false,
+            type: "error",
+            command,
+            message: err.message,
+        }));
+    });
+    return JSON.stringify({ ok: true, type: "started", command });
+}