@zaclinley/dsh-mailharbor 0.0.0-stage → 0.2.0

package/lib/index.js

@@ -0,0 +1,2941 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
+// src/host/address.ts
+function splitAddressHeader(value) {
+  const text2 = value.trim();
+  if (text2 === "") return [];
+  const parts = [];
+  let current = "";
+  let quoted = false;
+  let angle = 0;
+  for (const ch of text2) {
+    if (ch === '"') quoted = !quoted;
+    if (ch === "<" && !quoted) angle += 1;
+    if (ch === ">" && !quoted && angle > 0) angle -= 1;
+    if ((ch === "," || ch === ";") && !quoted && angle === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts.map((part) => part.trim()).filter((part) => part !== "");
+}
+function parseAddress(token) {
+  const text2 = token.trim();
+  if (text2 === "") return null;
+  const angled = /^(.*?)\s*<([^>]+)>\s*$/.exec(text2);
+  if (angled !== null) {
+    const name2 = (angled[1] ?? "").trim().replace(/^"|"$/g, "").trim();
+    const address = (angled[2] ?? "").trim();
+    return address === "" ? null : { name: name2, address };
+  }
+  if (/^[^\s@]+@[^\s@]+$/.test(text2)) return { name: "", address: text2 };
+  return null;
+}
+function parseAddressList(value) {
+  return splitAddressHeader(value).map(parseAddress).filter((address) => address !== null);
+}
+function formatAddressList(list) {
+  return list.map((address) => address.name !== "" ? `${address.name} <${address.address}>` : address.address).filter((text2) => text2 !== "").join(", ");
+}
+function addressOf(value) {
+  const angled = /<([^>]+)>/.exec(value);
+  return (angled === null ? value : angled[1] ?? "").trim();
+}
+function isEmail(value) {
+  return /^[^\s@]+@[^\s@]+$/.test(value.trim());
+}
+var init_address = __esm({
+  "src/host/address.ts"() {
+    "use strict";
+  }
+});
+
+// src/host/smtp.ts
+var smtp_exports = {};
+__export(smtp_exports, {
+  recipientsOf: () => recipientsOf,
+  sendMail: () => sendMail,
+  verifySmtp: () => verifySmtp
+});
+import nodemailer from "nodemailer";
+function transportOptions(settings, credentials, security = {}) {
+  const secure = settings.secure !== false;
+  return {
+    host: settings.host,
+    port: Number(settings.port),
+    secure,
+    // Plain submission ports must upgrade; never send credentials in the clear.
+    requireTLS: !secure,
+    auth: credentials.accessToken !== void 0 ? { type: "OAuth2", user: credentials.user, accessToken: credentials.accessToken } : { user: credentials.user, pass: credentials.pass ?? "" },
+    tls: { rejectUnauthorized: security.allowSelfSigned !== true, servername: settings.host },
+    connectionTimeout: 2e4,
+    greetingTimeout: 2e4,
+    socketTimeout: 12e4,
+    pool: false
+  };
+}
+function createTransport(settings, credentials, security = {}) {
+  return nodemailer.createTransport(transportOptions(settings, credentials, security));
+}
+function recipientsOf(value) {
+  return value.split(/[,;]/).map((part) => addressOf(part)).filter((address) => isEmail(address));
+}
+async function verifySmtp(settings, credentials, security = {}) {
+  const transport = createTransport(settings, credentials, security);
+  try {
+    await transport.verify();
+    return { ok: true, host: settings.host, port: Number(settings.port) };
+  } finally {
+    transport.close();
+  }
+}
+async function sendMail(settings, credentials, account, mail, security = {}) {
+  const from = addressOf(mail.from ?? account);
+  if (!isEmail(from)) throw new Error("\u53D1\u4EF6\u4EBA\u5730\u5740\u65E0\u6548");
+  const to = recipientsOf(mail.to);
+  const cc = recipientsOf(mail.cc ?? "");
+  if (to.length === 0) throw new Error("\u6536\u4EF6\u4EBA\u4E0D\u80FD\u4E3A\u7A7A");
+  const transport = createTransport(settings, credentials, security);
+  try {
+    const info = await transport.sendMail({
+      from: settings.fromName === "" ? from : { name: settings.fromName, address: from },
+      to,
+      ...cc.length > 0 ? { cc } : {},
+      subject: mail.subject,
+      text: mail.text,
+      ...mail.html !== void 0 && mail.html.trim() !== "" ? { html: mail.html } : {},
+      ...mail.inReplyTo !== void 0 && mail.inReplyTo !== "" ? { inReplyTo: mail.inReplyTo } : {},
+      ...mail.references !== void 0 && mail.references !== "" ? { references: mail.references } : {},
+      ...mail.attachments !== void 0 && mail.attachments.length > 0 ? {
+        attachments: mail.attachments.map((file) => ({
+          filename: file.filename,
+          content: file.content,
+          contentType: file.contentType
+        }))
+      } : {}
+    });
+    return {
+      messageId: String(info.messageId ?? ""),
+      accepted: (info.accepted ?? []).map((entry) => String(entry)),
+      rejected: (info.rejected ?? []).map((entry) => String(entry))
+    };
+  } finally {
+    transport.close();
+  }
+}
+var init_smtp = __esm({
+  "src/host/smtp.ts"() {
+    "use strict";
+    init_address();
+  }
+});
+
+// src/host/imap.ts
+var imap_exports = {};
+__export(imap_exports, {
+  ImapProvider: () => ImapProvider,
+  addressOf: () => addressOf,
+  formatAddressList: () => formatAddressList,
+  parseAddressList: () => parseAddressList
+});
+import { ImapFlow as ImapFlow2 } from "imapflow";
+import { simpleParser as simpleParser2 } from "mailparser";
+function normalizeId2(value) {
+  return String(value ?? "").trim().replace(/^<|>$/g, "").trim();
+}
+function isoDate(value) {
+  const date = value instanceof Date ? value : value === void 0 || value === null ? void 0 : new Date(String(value));
+  return date instanceof Date && !Number.isNaN(date.getTime()) ? date.toISOString() : "";
+}
+function flagsOf(value) {
+  if (value === void 0 || value === null) return [];
+  return [...value].map((flag) => String(flag));
+}
+function isSeen(flags) {
+  return flags.some((flag) => flag.toLowerCase() === "\\seen");
+}
+function attachmentList(parsed) {
+  return (parsed.attachments ?? []).map((attachment, index) => ({
+    id: String(index),
+    filename: String(attachment.filename ?? "attachment"),
+    contentType: String(attachment.contentType ?? "application/octet-stream"),
+    size: Number(attachment.size ?? attachment.content?.length ?? 0)
+  }));
+}
+function toMessage(message) {
+  const flags = flagsOf(message.flags);
+  const addressList = (value) => (value ?? []).map((entry) => ({ name: entry.name ?? "", address: entry.address ?? "" })).filter((address) => address.address !== "");
+  return {
+    uid: Number(message.uid),
+    messageId: normalizeId2(message.envelope?.messageId),
+    subject: String(message.envelope?.subject ?? "(\u65E0\u4E3B\u9898)"),
+    from: addressList(message.envelope?.from)[0] ?? { name: "", address: "" },
+    to: addressList(message.envelope?.to),
+    cc: addressList(message.envelope?.cc),
+    date: isoDate(message.internalDate ?? message.envelope?.date),
+    size: Number(message.size ?? 0),
+    flags,
+    read: isSeen(flags)
+  };
+}
+function messageOf3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isFatal(error) {
+  if (error instanceof Error) {
+    const code = error.code ?? "";
+    if (/^(NoConnection|ConnectionClosed|ConnectionNotAvailable|EConnectionClosed|ETIMEDOUT|ECONNRESET|EPIPE)$/.test(
+      code
+    )) {
+      return true;
+    }
+    return /connection (closed|lost|not available)|socket/i.test(error.message);
+  }
+  return false;
+}
+var ImapProvider;
+var init_imap = __esm({
+  "src/host/imap.ts"() {
+    "use strict";
+    init_address();
+    ImapProvider = class {
+      settings;
+      credentials;
+      options;
+      client = null;
+      connecting = null;
+      queue = Promise.resolve();
+      disposed = false;
+      constructor(settings, credentials, options = {}) {
+        this.settings = settings;
+        this.credentials = credentials;
+        this.options = options;
+      }
+      async connect() {
+        if (this.client !== null && this.client.usable) return this.client;
+        if (this.connecting !== null) return this.connecting;
+        this.connecting = (async () => {
+          const client = new ImapFlow2({
+            host: this.settings.host,
+            port: Number(this.settings.port),
+            secure: this.settings.secure !== false,
+            auth: this.credentials.accessToken !== void 0 ? { user: this.credentials.user, accessToken: this.credentials.accessToken } : { user: this.credentials.user, pass: this.credentials.pass ?? "" },
+            logger: false,
+            tls: { rejectUnauthorized: true },
+            connectionTimeout: this.options.connectionTimeoutMs ?? 15e3,
+            greetingTimeout: this.options.connectionTimeoutMs ?? 15e3,
+            socketTimeout: this.options.socketTimeoutMs ?? 6e4
+          });
+          client.on("error", () => {
+          });
+          client.on("close", () => {
+            if (this.client === client) this.client = null;
+          });
+          try {
+            await client.connect();
+          } catch (error) {
+            throw new Error(
+              `IMAP \u8FDE\u63A5\u5931\u8D25 (${this.settings.host}:${String(this.settings.port)}): ${messageOf3(error)}`
+            );
+          }
+          this.client = client;
+          return client;
+        })();
+        try {
+          return await this.connecting;
+        } finally {
+          this.connecting = null;
+        }
+      }
+      async reset(reason) {
+        const client = this.client;
+        this.client = null;
+        if (client !== null) {
+          try {
+            await client.logout();
+          } catch {
+          }
+        }
+        if (!this.disposed) this.options.onReconnect?.(reason);
+      }
+      /** Serialize one operation on this account's connection. */
+      run(operation) {
+        const task = this.queue.then(
+          async () => {
+            const client = await this.connect();
+            try {
+              return await operation(client);
+            } catch (error) {
+              if (isFatal(error)) await this.reset(messageOf3(error));
+              throw error;
+            }
+          },
+          async () => {
+            const client = await this.connect();
+            return operation(client);
+          }
+        );
+        this.queue = task.then(
+          () => void 0,
+          () => void 0
+        );
+        return task;
+      }
+      async check() {
+        return this.run(async (client) => {
+          const boxes = await this.listMailboxes(client);
+          return { ok: true, mailboxes: boxes.map((box) => ({ name: box.path, count: box.messages })) };
+        });
+      }
+      async mailboxes() {
+        return this.run((client) => this.listMailboxes(client));
+      }
+      async listMailboxes(client) {
+        const listed = await client.list();
+        const result = [];
+        for (const box of listed) {
+          if (box.flags?.has?.("\\Noselect") === true) continue;
+          let messages = 0;
+          try {
+            const status = await client.status(box.path, { messages: true });
+            if (status !== false) messages = Number(status.messages ?? 0);
+          } catch {
+          }
+          result.push({
+            path: box.path,
+            name: box.name ?? box.path,
+            specialUse: box.specialUse ?? null,
+            messages
+          });
+        }
+        return result;
+      }
+      async list(mailbox, limit) {
+        return this.run(async (client) => {
+          const lock = await client.getMailboxLock(mailbox);
+          try {
+            const total = Number(client.mailbox?.exists ?? 0);
+            if (total === 0) return { total: 0, items: [] };
+            const start = Math.max(1, total - limit + 1);
+            const items = [];
+            for await (const message of client.fetch(`${String(start)}:*`, {
+              uid: true,
+              envelope: true,
+              flags: true,
+              internalDate: true,
+              size: true
+            })) {
+              items.push(toMessage(message));
+            }
+            items.sort((left, right) => right.date.localeCompare(left.date));
+            return { total, items };
+          } finally {
+            lock.release();
+          }
+        });
+      }
+      async read(mailbox, uid) {
+        return this.run(async (client) => {
+          const lock = await client.getMailboxLock(mailbox);
+          try {
+            const message = await client.fetchOne(
+              uid,
+              { uid: true, source: true, flags: true, envelope: true, internalDate: true, size: true },
+              { uid: true }
+            );
+            if (message === false || message === void 0 || message.source === void 0) {
+              throw new Error("\u90AE\u4EF6\u4E0D\u5B58\u5728");
+            }
+            const parsed = await simpleParser2(message.source);
+            const base = toMessage(message);
+            const html = typeof parsed.html === "string" ? parsed.html : Buffer.isBuffer(parsed.html) ? parsed.html.toString("utf8") : null;
+            return {
+              ...base,
+              text: typeof parsed.text === "string" ? parsed.text : "",
+              html: html === "" ? null : html,
+              attachments: attachmentList(parsed),
+              inReplyTo: normalizeId2(parsed.inReplyTo),
+              references: String(parsed.references ?? "").split(/\s+/).map(normalizeId2).filter((item) => item !== "")
+            };
+          } finally {
+            lock.release();
+          }
+        });
+      }
+      async attachment(mailbox, uid, part) {
+        return this.run(async (client) => {
+          const lock = await client.getMailboxLock(mailbox);
+          try {
+            const message = await client.fetchOne(uid, { uid: true, source: true }, { uid: true });
+            if (message === false || message === void 0 || message.source === void 0) {
+              throw new Error("\u90AE\u4EF6\u4E0D\u5B58\u5728");
+            }
+            const parsed = await simpleParser2(message.source);
+            const attachment = parsed.attachments?.[part];
+            if (attachment === void 0) throw new Error("\u9644\u4EF6\u4E0D\u5B58\u5728");
+            return {
+              filename: String(attachment.filename ?? "attachment"),
+              contentType: String(attachment.contentType ?? "application/octet-stream"),
+              dataBase64: attachment.content.toString("base64")
+            };
+          } finally {
+            lock.release();
+          }
+        });
+      }
+      async unseen() {
+        return this.run(async (client) => {
+          const lock = await client.getMailboxLock("INBOX");
+          try {
+            const found = await client.search({ seen: false }, { uid: true });
+            const uids = Array.isArray(found) ? found : [];
+            const items = [];
+            if (uids.length > 0) {
+              const range = uids.slice(-200).join(",");
+              for await (const message of client.fetch(range, { uid: true, envelope: true }, { uid: true })) {
+                items.push({
+                  uid: Number(message.uid),
+                  messageId: normalizeId2(message.envelope?.messageId)
+                });
+              }
+            }
+            return { count: uids.length, items };
+          } finally {
+            lock.release();
+          }
+        });
+      }
+      async setSeen(mailbox, uid, seen) {
+        return this.run(async (client) => {
+          const lock = await client.getMailboxLock(mailbox);
+          try {
+            if (seen) await client.messageFlagsAdd(uid, ["\\Seen"], { uid: true });
+            else await client.messageFlagsRemove(uid, ["\\Seen"], { uid: true });
+            const message = await client.fetchOne(uid, { uid: true, flags: true }, { uid: true });
+            const flags = flagsOf(message === false || message === void 0 ? [] : message.flags);
+            return { read: isSeen(flags), flags };
+          } finally {
+            lock.release();
+          }
+        });
+      }
+      /** Set \Seen by Message-ID, which is how local-archive rows reach the server. */
+      async setSeenByMessageId(mailbox, messageId, seen) {
+        return this.run(async (client) => {
+          const lock = await client.getMailboxLock(mailbox);
+          try {
+            const id = normalizeId2(messageId);
+            let found = await client.search({ header: { "Message-ID": id } }, { uid: true });
+            if (!Array.isArray(found) || found.length === 0) {
+              found = await client.search({ header: { "Message-ID": `<${id}>` } }, { uid: true });
+            }
+            const uids = Array.isArray(found) ? found : [];
+            const uid = uids[uids.length - 1];
+            if (uid === void 0) return { found: false };
+            if (seen) await client.messageFlagsAdd(uid, ["\\Seen"], { uid: true });
+            else await client.messageFlagsRemove(uid, ["\\Seen"], { uid: true });
+            const message = await client.fetchOne(uid, { uid: true, flags: true }, { uid: true });
+            const flags = flagsOf(message === false || message === void 0 ? [] : message.flags);
+            return { found: true, uid: Number(uid), read: isSeen(flags) };
+          } finally {
+            lock.release();
+          }
+        });
+      }
+      async dispose() {
+        this.disposed = true;
+        await this.reset("dispose");
+      }
+    };
+  }
+});
+
+// src/host/api.ts
+init_address();
+
+// src/host/config.ts
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+
+// src/host/paths.ts
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+var DATA_ROOT = process.env.DSH_MAILHARBOR_DATA_DIR ?? join(homedir(), ".dsh", "mailharbor");
+var CONFIG_PATH = process.env.DSH_MAILHARBOR_CONFIG ?? join(DATA_ROOT, "config.json");
+var ACCOUNTS_DIR = join(DATA_ROOT, "accounts");
+var STATE_DIR = join(DATA_ROOT, "state");
+var REPORTS_DIR = join(DATA_ROOT, "reports");
+var LOGS_DIR = join(DATA_ROOT, "logs");
+function accountRoot(id) {
+  const safe = id.replace(/[^A-Za-z0-9_-]/g, "_") || "unknown";
+  return join(ACCOUNTS_DIR, safe);
+}
+function accountDataDir(account) {
+  const configured = typeof account.dataDir === "string" ? account.dataDir.trim() : "";
+  if (configured === "") return accountRoot(account.id);
+  return isAbsolute(configured) ? configured : join(DATA_ROOT, configured);
+}
+function accountMailDb(account) {
+  return join(accountDataDir(account), "mail.db");
+}
+function accountAttachmentsDir(account) {
+  return join(accountDataDir(account), "attachments");
+}
+
+// src/host/config.ts
+var DEFAULTS = {
+  signature: "",
+  ai: {
+    enabled: true,
+    provider: "deepseek-account",
+    model: "deepseek-flash",
+    styleSampleCount: 100,
+    maxChars: 4e4
+  },
+  read: { markOnOpen: true, pollSeconds: 60 },
+  render: { listLimit: 40 },
+  oauth: {
+    google: { clientId: "", redirectPort: 8765, scopes: ["https://mail.google.com/"] },
+    microsoft: {
+      clientId: "",
+      scopes: [
+        "offline_access",
+        "https://outlook.office.com/IMAP.AccessAsUser.All",
+        "https://outlook.office.com/SMTP.Send"
+      ]
+    }
+  }
+};
+var ACCOUNT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var EMAIL = /^[^@\s]+@[^@\s]+$/;
+function stringOr(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function intOr(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) return fallback;
+  return parsed;
+}
+function hostOr(value, fallback) {
+  const text2 = stringOr(value, fallback).trim();
+  return text2 === "" ? fallback : text2;
+}
+function deriveAccountId(email, existing = []) {
+  const taken = new Set(existing);
+  const base = `acc_${createHash("sha1").update(email.trim().toLowerCase()).digest("hex").slice(0, 8)}`;
+  if (!taken.has(base)) return base;
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const candidate = `acc_${createHash("sha1").update(`${email}:${attempt}`).digest("hex").slice(0, 8)}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return `acc_${randomUUID().slice(0, 8)}`;
+}
+function normalizeAccount(input, index = 0, existing = []) {
+  const email = stringOr(input.email, "").trim();
+  if (!EMAIL.test(email)) throw new Error("\u90AE\u7BB1\u5730\u5740\u683C\u5F0F\u4E0D\u6B63\u786E");
+  const id = typeof input.id === "string" && ACCOUNT_ID.test(input.id) ? input.id : deriveAccountId(email, [...existing, `index:${String(index)}`]);
+  const domain = email.split("@")[1] ?? "example.com";
+  const username = stringOr(input.username, email).trim() || email;
+  return {
+    id,
+    label: stringOr(input.label, email).trim() || email,
+    email,
+    username,
+    imap: {
+      host: hostOr(input.imap?.host, `imap.${domain}`),
+      port: intOr(input.imap?.port, 993, 1, 65535),
+      secure: input.imap?.secure !== false
+    },
+    smtp: {
+      host: hostOr(input.smtp?.host, `smtp.${domain}`),
+      port: intOr(input.smtp?.port, 465, 1, 65535),
+      secure: input.smtp?.secure !== false,
+      fromName: stringOr(input.smtp?.fromName, "")
+    },
+    keychainService: stringOr(input.keychainService, `dsh-mailharbor:${id}`),
+    dataDir: stringOr(input.dataDir, `accounts/${id}`),
+    auth: input.auth?.type === "oauth2" ? { type: "oauth2", provider: input.auth.provider } : { type: "password" },
+    caldav: normalizeCaldav(input.caldav),
+    enabled: input.enabled !== false,
+    createdAt: stringOr(input.createdAt, (/* @__PURE__ */ new Date()).toISOString())
+  };
+}
+function normalizeCaldav(value) {
+  if (value === null || value === void 0) return null;
+  const url = stringOr(value.url, "").trim();
+  if (url === "") return null;
+  return {
+    url,
+    username: stringOr(value.username, "").trim(),
+    ...typeof value.calendarHref === "string" && value.calendarHref !== "" ? { calendarHref: value.calendarHref } : {}
+  };
+}
+function readFileConfig() {
+  try {
+    if (!existsSync(CONFIG_PATH)) return {};
+    const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    return parsed !== null && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function loadConfig() {
+  const file = readFileConfig();
+  const rawAccounts = Array.isArray(file.accounts) ? file.accounts : [];
+  const accounts = [];
+  for (const [index, raw] of rawAccounts.entries()) {
+    if (raw === null || typeof raw !== "object") continue;
+    try {
+      accounts.push(
+        normalizeAccount(
+          raw,
+          index,
+          accounts.map((account) => account.id)
+        )
+      );
+    } catch {
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = accounts.filter((account) => {
+    if (seen.has(account.id)) return false;
+    seen.add(account.id);
+    return true;
+  });
+  const requested = stringOr(file.activeAccountId, "");
+  const activeAccountId = unique.some((account) => account.id === requested) ? requested : unique.find((account) => account.enabled !== false)?.id ?? null;
+  const aiRaw = file.ai ?? {};
+  const readRaw = file.read ?? {};
+  const renderRaw = file.render ?? {};
+  const oauthRaw = file.oauth ?? {};
+  const googleRaw = oauthRaw.google ?? {};
+  const microsoftRaw = oauthRaw.microsoft ?? {};
+  return {
+    dataDir: DATA_ROOT,
+    configFile: CONFIG_PATH,
+    accounts: unique,
+    activeAccountId,
+    signature: stringOr(file.signature, DEFAULTS.signature),
+    ai: {
+      enabled: aiRaw.enabled !== false,
+      provider: stringOr(aiRaw.provider, DEFAULTS.ai.provider),
+      model: stringOr(aiRaw.model, DEFAULTS.ai.model),
+      styleSampleCount: intOr(aiRaw.styleSampleCount, DEFAULTS.ai.styleSampleCount, 10, 200),
+      maxChars: intOr(aiRaw.maxChars, DEFAULTS.ai.maxChars, 1e3, 2e5)
+    },
+    read: {
+      markOnOpen: readRaw.markOnOpen !== false,
+      pollSeconds: intOr(readRaw.pollSeconds, DEFAULTS.read.pollSeconds, 15, 3600)
+    },
+    render: {
+      listLimit: intOr(renderRaw.listLimit, DEFAULTS.render.listLimit, 10, 200)
+    },
+    oauth: {
+      google: {
+        clientId: stringOr(googleRaw.clientId, DEFAULTS.oauth.google.clientId),
+        redirectPort: intOr(googleRaw.redirectPort, DEFAULTS.oauth.google.redirectPort, 1024, 65535),
+        scopes: Array.isArray(googleRaw.scopes) ? googleRaw.scopes.filter((item) => typeof item === "string") : DEFAULTS.oauth.google.scopes
+      },
+      microsoft: {
+        clientId: stringOr(microsoftRaw.clientId, DEFAULTS.oauth.microsoft.clientId),
+        scopes: Array.isArray(microsoftRaw.scopes) ? microsoftRaw.scopes.filter((item) => typeof item === "string") : DEFAULTS.oauth.microsoft.scopes
+      }
+    },
+    revision: Date.now()
+  };
+}
+function writeConfigFile(patch) {
+  const current = readFileConfig();
+  const next = { ...current, ...patch };
+  if (current.accounts !== void 0 || patch.accounts !== void 0) {
+    next.accounts = patch.accounts ?? current.accounts;
+  }
+  mkdirSync(DATA_ROOT, { recursive: true });
+  const temp = `${CONFIG_PATH}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+  renameSync(temp, CONFIG_PATH);
+  return next;
+}
+function saveSettings(patch) {
+  writeConfigFile(patch);
+}
+function saveAccounts(accounts, activeAccountId) {
+  writeConfigFile({ accounts, activeAccountId });
+}
+function buildAccount(input, existing) {
+  const email = input.email.trim();
+  if (!EMAIL.test(email)) throw new Error("\u90AE\u7BB1\u5730\u5740\u683C\u5F0F\u4E0D\u6B63\u786E");
+  const id = deriveAccountId(
+    email,
+    existing.map((account) => account.id)
+  );
+  return normalizeAccount(
+    {
+      id,
+      email,
+      label: input.label,
+      username: input.username,
+      imap: input.imap,
+      smtp: input.smtp,
+      auth: { type: "password" },
+      caldav: null,
+      enabled: true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    0,
+    existing.map((account) => account.id)
+  );
+}
+function accountRuntime(account) {
+  const root = accountDataDir(account);
+  return {
+    account,
+    root,
+    mailDb: accountMailDb(account),
+    attachments: accountAttachmentsDir(account),
+    keychainService: account.keychainService || `dsh-mailharbor:${account.id}`,
+    imap: account.imap,
+    smtp: account.smtp,
+    auth: account.auth
+  };
+}
+function requireAccount(config, id) {
+  const account = config.accounts.find((item) => item.id === id) ?? config.accounts.find((item) => item.id === config.activeAccountId);
+  if (account === void 0) throw new Error("\u8BF7\u5148\u6DFB\u52A0\u4E00\u4E2A\u90AE\u7BB1\u8D26\u53F7");
+  return account;
+}
+function activeAccount(config) {
+  return config.accounts.find((account) => account.id === config.activeAccountId) ?? null;
+}
+
+// src/host/backup.ts
+init_address();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { ImapFlow } from "imapflow";
+import { simpleParser } from "mailparser";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
+// src/host/mail-db.ts
+init_address();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS emails (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    mailbox TEXT NOT NULL,
+    uid INTEGER,
+    subject TEXT,
+    from_name TEXT,
+    from_addr TEXT,
+    to_addr TEXT,
+    cc TEXT,
+    date TEXT,
+    message_id TEXT UNIQUE,
+    body_text TEXT,
+    body_html TEXT,
+    raw_eml BLOB,
+    hash TEXT,
+    backup_log_id INTEGER,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+  CREATE TABLE IF NOT EXISTS attachments (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    email_id INTEGER NOT NULL,
+    filename TEXT NOT NULL,
+    content_type TEXT,
+    size INTEGER,
+    data BLOB,
+    hash TEXT
+  );
+  CREATE TABLE IF NOT EXISTS backup_logs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    started_at TEXT NOT NULL,
+    completed_at TEXT,
+    mailboxes TEXT,
+    new_count INTEGER DEFAULT 0,
+    fail_count INTEGER DEFAULT 0,
+    total_emails INTEGER DEFAULT 0,
+    cumulative_hash TEXT,
+    status TEXT DEFAULT 'running',
+    error_info TEXT
+  );
+  CREATE TABLE IF NOT EXISTS backup_state (
+    mailbox TEXT PRIMARY KEY,
+    uid_validity TEXT,
+    last_uid INTEGER,
+    updated_at TEXT
+  );
+`;
+var INDEXES = `
+  CREATE INDEX IF NOT EXISTS idx_emails_mailbox_date ON emails(mailbox, date);
+  CREATE INDEX IF NOT EXISTS idx_emails_date ON emails(date);
+  CREATE INDEX IF NOT EXISTS idx_attachments_email ON attachments(email_id);
+`;
+var FTS = `CREATE VIRTUAL TABLE IF NOT EXISTS emails_fts USING fts5(
+  subject, from_name, from_addr, to_addr, cc, body_text, att_filename,
+  content='', tokenize='trigram'
+)`;
+function ensureMailSchema(file) {
+  const db = new DatabaseSync(file);
+  try {
+    db.exec("PRAGMA journal_mode=WAL");
+    db.exec(SCHEMA);
+    db.exec(INDEXES);
+    try {
+      db.exec(FTS);
+    } catch {
+    }
+  } finally {
+    db.close();
+  }
+}
+var MailDatabase = class {
+  file;
+  options;
+  db;
+  ftsChecked = false;
+  ftsAvailable = false;
+  constructor(file, options = {}) {
+    this.file = file;
+    this.options = options;
+  }
+  get path() {
+    return this.file;
+  }
+  isOpen() {
+    return this.db !== void 0;
+  }
+  open() {
+    if (this.db !== void 0) return this.db;
+    if (!existsSync2(this.file)) throw new Error(`\u90AE\u4EF6\u6570\u636E\u5E93\u4E0D\u5B58\u5728: ${this.file}`);
+    this.db = new DatabaseSync(this.file, { readOnly: true });
+    this.db.exec("PRAGMA busy_timeout = 3000");
+    return this.db;
+  }
+  close() {
+    if (this.db === void 0) return;
+    try {
+      this.db.close();
+    } catch {
+    }
+    this.db = void 0;
+  }
+  status() {
+    try {
+      const row = this.open().prepare("SELECT COUNT(*) AS count FROM emails").get();
+      return { ok: true, database: this.file, total: Number(row?.count ?? 0) };
+    } catch (error) {
+      return { ok: false, database: this.file, total: 0, error: messageOf(error) };
+    }
+  }
+  /** Per-mailbox counts, largest first. */
+  mailboxes() {
+    const rows = this.open().prepare("SELECT mailbox, COUNT(*) AS count FROM emails GROUP BY mailbox ORDER BY count DESC").all();
+    return rows.map((row) => ({ name: String(row.mailbox), count: Number(row.count ?? 0) }));
+  }
+  supportsFts() {
+    if (this.ftsChecked) return this.ftsAvailable;
+    this.ftsChecked = true;
+    try {
+      const row = this.open().prepare("SELECT 1 AS found FROM sqlite_master WHERE type = 'table' AND name = 'emails_fts'").get();
+      this.ftsAvailable = row !== void 0;
+    } catch {
+      this.ftsAvailable = false;
+    }
+    return this.ftsAvailable;
+  }
+  list(query = {}) {
+    const db = this.open();
+    const mailbox = String(query.mailbox ?? "all");
+    const offset = Math.max(0, Math.trunc(query.offset ?? 0));
+    const limit = Math.min(500, Math.max(1, Math.trunc(query.limit ?? 40)));
+    const where = [];
+    const params = [];
+    if (mailbox !== "" && mailbox !== "all") {
+      where.push("e.mailbox = ?");
+      params.push(mailbox);
+    }
+    if (typeof query.since === "string" && query.since !== "") {
+      where.push("e.date >= ?");
+      params.push(query.since);
+    }
+    const text2 = String(query.query ?? "").trim();
+    if (text2 !== "") {
+      const tokens = text2.split(/\s+/).filter(Boolean);
+      const short = tokens.some((token) => token.length < 3);
+      if (!short && this.supportsFts()) {
+        const like = `%${text2}%`;
+        where.push(
+          "(e.id IN (SELECT rowid FROM emails_fts WHERE emails_fts MATCH ?) OR e.subject LIKE ? OR e.from_name LIKE ? OR e.from_addr LIKE ? OR e.to_addr LIKE ?)"
+        );
+        params.push(tokens.map(quoteMatch).join(" AND "), like, like, like, like);
+      } else {
+        for (const token of tokens) {
+          const like = `%${token}%`;
+          where.push(
+            "(e.subject LIKE ? OR e.from_name LIKE ? OR e.from_addr LIKE ? OR e.to_addr LIKE ? OR e.body_text LIKE ?)"
+          );
+          params.push(like, like, like, like, like);
+        }
+      }
+    }
+    const clause = where.length === 0 ? "" : `WHERE ${where.join(" AND ")}`;
+    const columns = `SELECT e.id, e.mailbox, e.uid, e.subject, e.from_name, e.from_addr, e.to_addr, e.cc,
+        e.message_id, e.date, length(e.body_text) AS text_length,
+        (SELECT COUNT(*) FROM attachments a WHERE a.email_id = e.id) AS attachment_count,
+        substr(COALESCE(e.body_text, ''), 1, 240) AS snippet`;
+    const total = Number(
+      db.prepare(`SELECT COUNT(*) AS count FROM emails e ${clause}`).get(...params)?.count ?? 0
+    );
+    const direction = query.order === "oldest" ? "ASC" : "DESC";
+    const rows = db.prepare(
+      `${columns} FROM emails e ${clause} ORDER BY e.date ${direction}, e.id ${direction} LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    return { items: rows.map((row) => rowToSummary(row)), total, offset, limit };
+  }
+  get(localId) {
+    const db = this.open();
+    const row = db.prepare(
+      `SELECT id, mailbox, uid, subject, from_name, from_addr, to_addr, cc, date, message_id,
+                body_text, body_html
+         FROM emails WHERE id = ?`
+    ).get(localId);
+    if (row === void 0) return void 0;
+    const attachments = db.prepare("SELECT id, filename, content_type, size FROM attachments WHERE email_id = ? ORDER BY id").all(localId).map((item) => ({
+      id: String(item.id),
+      filename: String(item.filename ?? "attachment"),
+      contentType: String(item.content_type ?? "application/octet-stream"),
+      size: Number(item.size ?? 0)
+    }));
+    const max = this.options.maxBodyChars ?? 4e5;
+    const bodyText = String(row.body_text ?? "");
+    const bodyHtml = String(row.body_html ?? "");
+    return {
+      ...rowToSummary(row),
+      cc: parseAddressList(String(row.cc ?? "")),
+      replyTo: [],
+      text: truncate(bodyText, max),
+      html: bodyHtml === "" ? null : truncate(bodyHtml, max * 2),
+      attachments,
+      references: []
+    };
+  }
+  /** Read one attachment's bytes; the payload may live in a file (content-addressed). */
+  attachment(emailId, attachmentId) {
+    const db = this.open();
+    const row = db.prepare("SELECT filename, content_type, data, hash FROM attachments WHERE id = ? AND email_id = ?").get(attachmentId, emailId);
+    if (row === void 0) return void 0;
+    let data = row.data instanceof Uint8Array ? row.data : null;
+    if (data === null && typeof row.hash === "string" && row.hash !== "") {
+      const root = this.options.attachmentsRoot ?? "";
+      if (root !== "") {
+        const file = `${root}/${row.hash.slice(0, 2)}/${row.hash.slice(2, 4)}/${row.hash}`;
+        if (existsSync2(file)) data = readFileSyncSafe(file);
+      }
+    }
+    if (data === null) return void 0;
+    return {
+      filename: String(row.filename ?? "attachment"),
+      contentType: String(row.content_type ?? "application/octet-stream"),
+      data
+    };
+  }
+  /** Whether the backup already holds a message with this Message-ID. */
+  hasMessageId(messageId) {
+    const id = messageId.trim().replace(/^<|>$/g, "");
+    if (id === "") return false;
+    try {
+      return this.open().prepare("SELECT 1 AS found FROM emails WHERE message_id = ? LIMIT 1").get(id) !== void 0;
+    } catch {
+      return false;
+    }
+  }
+  /** Latest backup runs, for the settings page. */
+  backupSummary() {
+    try {
+      const db = this.open();
+      const lastCompleted = db.prepare(
+        `SELECT id, started_at, completed_at, new_count, total_emails, status
+             FROM backup_logs WHERE status = 'completed' ORDER BY id DESC LIMIT 1`
+      ).get() ?? null;
+      const latest = db.prepare(
+        "SELECT id, started_at, completed_at, new_count, total_emails, status FROM backup_logs ORDER BY id DESC LIMIT 1"
+      ).get() ?? null;
+      return {
+        ok: true,
+        lastCompleted: toPlain(lastCompleted),
+        latest: toPlain(latest),
+        total: Number(db.prepare("SELECT COUNT(*) AS count FROM emails").get()?.count ?? 0)
+      };
+    } catch (error) {
+      return { ok: false, lastCompleted: null, latest: null, total: 0, error: messageOf(error) };
+    }
+  }
+};
+function toPlain(row) {
+  if (row === void 0 || row === null || typeof row !== "object") return null;
+  return { ...row };
+}
+function readFileSyncSafe(file) {
+  try {
+    return readFileSync2(file);
+  } catch {
+    return null;
+  }
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function truncate(value, max) {
+  return value.length <= max ? value : `${value.slice(0, max)}
+
+\u2026\uFF08\u5DF2\u622A\u65AD\uFF09`;
+}
+function quoteMatch(text2) {
+  return `"${text2.replaceAll('"', '""')}"`;
+}
+function rowToSummary(row) {
+  const fromName = String(row.from_name ?? "");
+  const fromAddr = String(row.from_addr ?? "");
+  return {
+    id: String(row.id),
+    accountId: "",
+    uid: row.uid === null || row.uid === void 0 ? void 0 : Number(row.uid),
+    messageId: String(row.message_id ?? ""),
+    subject: String(row.subject ?? "(\u65E0\u4E3B\u9898)"),
+    from: { name: fromName, address: fromAddr },
+    to: parseAddressList(String(row.to_addr ?? "")),
+    date: String(row.date ?? ""),
+    unread: false,
+    flagged: false,
+    hasAttachments: Number(row.attachment_count ?? 0) > 0,
+    snippet: String(row.snippet ?? "").replace(/\s+/g, " ").trim(),
+    mailbox: String(row.mailbox ?? "")
+  };
+}
+
+// src/host/backup.ts
+var BATCH = 25;
+function sha256(data) {
+  return createHash2("sha256").update(data).digest("hex");
+}
+function normalizeId(value) {
+  return String(value ?? "").trim().replace(/^<|>$/g, "").trim();
+}
+function stamp(value) {
+  const date = value instanceof Date ? value : value === void 0 || value === null ? void 0 : new Date(String(value));
+  if (!(date instanceof Date) || Number.isNaN(date.getTime())) return "";
+  const pad = (number) => String(number).padStart(2, "0");
+  return `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function abortIfNeeded(signal) {
+  if (signal?.aborted === true) {
+    const error = new Error("\u5907\u4EFD\u5DF2\u53D6\u6D88");
+    error.code = "backup-cancelled";
+    throw error;
+  }
+}
+var BackupEngine = class {
+  runtime;
+  credentials;
+  batchSize;
+  constructor(runtime, credentials, options = {}) {
+    this.runtime = runtime;
+    this.credentials = credentials;
+    this.batchSize = options.batchSize ?? BATCH;
+  }
+  attachmentsDir() {
+    return this.runtime.attachments;
+  }
+  openDb() {
+    ensureMailSchema(this.runtime.mailDb);
+    const db = new DatabaseSync2(this.runtime.mailDb);
+    db.exec("PRAGMA journal_mode=WAL");
+    db.exec("PRAGMA busy_timeout=10000");
+    db.exec("PRAGMA synchronous=NORMAL");
+    return db;
+  }
+  writeAttachment(data) {
+    const hash = sha256(data);
+    const dir = join2(this.attachmentsDir(), hash.slice(0, 2), hash.slice(2, 4));
+    const file = join2(dir, hash);
+    mkdirSync2(dir, { recursive: true });
+    if (!existsSync3(file)) writeFileSync2(file, data, { mode: 384 });
+    return { hash, size: data.length };
+  }
+  insertEmail(db, mailbox, message, parsed, logId) {
+    const source = message.source ?? Buffer.alloc(0);
+    const hash = sha256(source);
+    const from = parsed.from?.value?.[0] ?? { name: "", address: "" };
+    const messageId = normalizeId(parsed.messageId ?? message.envelope?.messageId);
+    const toText = parsedAddressText(parsed.to) || formatAddressList(parseAddressList(addressTextOf(message.envelope?.to)));
+    const ccText = parsedAddressText(parsed.cc) || formatAddressList(parseAddressList(addressTextOf(message.envelope?.cc)));
+    const subject = String(parsed.subject ?? message.envelope?.subject ?? "(\u65E0\u4E3B\u9898)");
+    const text2 = typeof parsed.text === "string" ? parsed.text : "";
+    const html = typeof parsed.html === "string" ? parsed.html : "";
+    const inserted = db.prepare(
+      `INSERT OR IGNORE INTO emails
+           (mailbox, uid, subject, from_name, from_addr, to_addr, cc, date, message_id,
+            body_text, body_html, raw_eml, hash, backup_log_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      mailbox,
+      Number(message.uid),
+      subject,
+      String(from.name ?? ""),
+      String(from.address ?? ""),
+      toText,
+      ccText,
+      stamp(parsed.date ?? message.internalDate ?? message.envelope?.date),
+      messageId === "" ? null : messageId,
+      text2,
+      html,
+      source,
+      hash,
+      logId
+    );
+    if (inserted.changes === 0) return 0;
+    const emailId = Number(inserted.lastInsertRowid);
+    const attachments = parsed.attachments ?? [];
+    const insertAttachment = db.prepare(
+      "INSERT INTO attachments (email_id, filename, content_type, size, hash) VALUES (?, ?, ?, ?, ?)"
+    );
+    for (const attachment of attachments) {
+      const data = attachment.content;
+      if (data === void 0 || data === null) continue;
+      const stored = this.writeAttachment(Buffer.isBuffer(data) ? data : Buffer.from(data));
+      insertAttachment.run(
+        emailId,
+        String(attachment.filename ?? "attachment"),
+        String(attachment.contentType ?? "application/octet-stream"),
+        stored.size,
+        stored.hash
+      );
+    }
+    try {
+      db.prepare(
+        `INSERT INTO emails_fts (rowid, subject, from_name, from_addr, to_addr, cc, body_text, att_filename)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        emailId,
+        subject,
+        String(from.name ?? ""),
+        String(from.address ?? ""),
+        toText,
+        ccText,
+        text2,
+        attachments.map((attachment) => attachment.filename).filter(Boolean).join(" ")
+      );
+    } catch {
+    }
+    return 1;
+  }
+  async run(options = {}) {
+    const emit = (event) => options.onEvent?.(event);
+    const signal = options.signal;
+    const db = this.openDb();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const logId = Number(
+      db.prepare(`INSERT INTO backup_logs (started_at, status) VALUES (?, 'running')`).run(startedAt).lastInsertRowid
+    );
+    const client = new ImapFlow({
+      host: this.runtime.imap.host,
+      port: Number(this.runtime.imap.port),
+      secure: this.runtime.imap.secure !== false,
+      auth: this.credentials.accessToken !== void 0 ? { user: this.credentials.user, accessToken: this.credentials.accessToken } : { user: this.credentials.user, pass: this.credentials.pass ?? "" },
+      logger: false,
+      tls: { rejectUnauthorized: true },
+      connectionTimeout: 2e4,
+      greetingTimeout: 2e4,
+      socketTimeout: 12e4
+    });
+    client.on("error", () => {
+    });
+    let newCount = 0;
+    let failCount = 0;
+    const mailboxes = [];
+    emit({ message: `\u5F00\u59CB\u5907\u4EFD ${this.runtime.account.email}` });
+    try {
+      await client.connect();
+      const boxes = await client.list();
+      for (const box of boxes) {
+        abortIfNeeded(signal);
+        if (box.flags?.has?.("\\Noselect") === true) continue;
+        const path = box.path;
+        emit({ mailbox: path, message: `\u68C0\u67E5 ${path}` });
+        const lock = await client.getMailboxLock(path);
+        let boxAdded = 0;
+        try {
+          const uidValidity = String(
+            client.mailbox?.uidValidity ?? ""
+          );
+          let state = db.prepare("SELECT uid_validity, last_uid FROM backup_state WHERE mailbox = ?").get(path);
+          if (state === void 0) {
+            const dbMax = Number(
+              db.prepare("SELECT MAX(uid) AS maxUid FROM emails WHERE mailbox = ?").get(path)?.maxUid ?? 0
+            );
+            this.saveState(db, path, uidValidity, dbMax);
+            state = { uid_validity: uidValidity, last_uid: dbMax };
+          } else if (uidValidity !== "" && String(state.uid_validity ?? "") !== uidValidity) {
+            this.saveState(db, path, uidValidity, 0);
+            state = { uid_validity: uidValidity, last_uid: 0 };
+            emit({ mailbox: path, message: `${path} \u7684 UIDVALIDITY \u53D8\u5316\uFF0C\u91CD\u65B0\u540C\u6B65` });
+          }
+          const lastUid = Number(state.last_uid ?? 0);
+          const found = await client.search({ uid: `${String(lastUid + 1)}:*` }, { uid: true });
+          const uids = (Array.isArray(found) ? found : []).filter((uid) => Number(uid) > lastUid).sort((left, right) => left - right);
+          let committedUid = lastUid;
+          for (let offset = 0; offset < uids.length; offset += this.batchSize) {
+            abortIfNeeded(signal);
+            const batch = uids.slice(offset, offset + this.batchSize);
+            db.exec("BEGIN");
+            try {
+              let batchLastUid = committedUid;
+              for await (const message of client.fetch(
+                batch.join(","),
+                { uid: true, source: true, flags: true, internalDate: true },
+                { uid: true }
+              )) {
+                abortIfNeeded(signal);
+                try {
+                  const parsed = await simpleParser(message.source ?? Buffer.alloc(0));
+                  const added = this.insertEmail(
+                    db,
+                    path,
+                    message,
+                    parsed,
+                    logId
+                  );
+                  boxAdded += added;
+                  newCount += added;
+                  batchLastUid = Math.max(batchLastUid, Number(message.uid));
+                } catch (error) {
+                  failCount += 1;
+                  emit({
+                    mailbox: path,
+                    message: `\u90AE\u4EF6 ${String(message.uid)} \u89E3\u6790\u5931\u8D25: ${messageOf2(error)}`
+                  });
+                }
+              }
+              this.saveState(db, path, uidValidity, batchLastUid);
+              db.exec("COMMIT");
+              committedUid = batchLastUid;
+              emit({ mailbox: path, added: boxAdded, message: `${path}: \u5DF2\u65B0\u589E ${String(boxAdded)} \u5C01` });
+            } catch (error) {
+              db.exec("ROLLBACK");
+              throw error;
+            }
+          }
+          mailboxes.push({ name: path, added: boxAdded });
+          emit({ mailbox: path, added: boxAdded, message: `${path}: \u65B0\u589E ${String(boxAdded)} \u5C01` });
+        } finally {
+          lock.release();
+        }
+      }
+      const total = Number(db.prepare("SELECT COUNT(*) AS n FROM emails").get()?.n ?? 0);
+      db.prepare(
+        `UPDATE backup_logs SET completed_at = ?, mailboxes = ?, new_count = ?, fail_count = ?,
+                total_emails = ?, status = 'completed' WHERE id = ?`
+      ).run((/* @__PURE__ */ new Date()).toISOString(), JSON.stringify(mailboxes), newCount, failCount, total, logId);
+      emit({
+        total,
+        added: newCount,
+        message: `\u5907\u4EFD\u5B8C\u6210\uFF1A\u65B0\u589E ${String(newCount)} \u5C01\uFF0C\u5171 ${String(total)} \u5C01`
+      });
+      return { ok: true, newCount, failCount, total, mailboxes };
+    } catch (error) {
+      const total = Number(db.prepare("SELECT COUNT(*) AS n FROM emails").get()?.n ?? 0);
+      db.prepare(
+        `UPDATE backup_logs SET completed_at = ?, mailboxes = ?, new_count = ?, fail_count = ?,
+                total_emails = ?, status = 'failed', error_info = ? WHERE id = ?`
+      ).run(
+        (/* @__PURE__ */ new Date()).toISOString(),
+        JSON.stringify(mailboxes),
+        newCount,
+        failCount,
+        total,
+        messageOf2(error).slice(0, 1e3),
+        logId
+      );
+      throw error;
+    } finally {
+      try {
+        await client.logout();
+      } catch {
+      }
+      db.close();
+    }
+  }
+  saveState(db, mailbox, uidValidity, lastUid) {
+    db.prepare(
+      `INSERT INTO backup_state (mailbox, uid_validity, last_uid, updated_at) VALUES (?, ?, ?, ?)
+       ON CONFLICT(mailbox) DO UPDATE SET uid_validity = excluded.uid_validity,
+         last_uid = excluded.last_uid, updated_at = excluded.updated_at`
+    ).run(mailbox, uidValidity, Number(lastUid), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /** Latest backup summary for the settings page. */
+  static status(dbFile) {
+    const empty = {
+      running: false,
+      accountId: null,
+      startedAt: null,
+      finishedAt: null,
+      lastSuccessAt: null,
+      total: 0,
+      added: 0,
+      message: "",
+      output: [],
+      exitCode: null
+    };
+    if (!existsSync3(dbFile)) return empty;
+    try {
+      const db = new DatabaseSync2(dbFile, { readOnly: true });
+      try {
+        const latest = db.prepare("SELECT * FROM backup_logs ORDER BY id DESC LIMIT 1").get();
+        const success = db.prepare("SELECT completed_at FROM backup_logs WHERE status = 'completed' ORDER BY id DESC LIMIT 1").get();
+        const total = Number(db.prepare("SELECT COUNT(*) AS n FROM emails").get()?.n ?? 0);
+        return {
+          ...empty,
+          running: latest?.status === "running",
+          startedAt: latest?.started_at === void 0 ? null : String(latest.started_at),
+          finishedAt: latest?.completed_at === void 0 ? null : String(latest.completed_at),
+          lastSuccessAt: success?.completed_at === void 0 ? null : String(success.completed_at),
+          total,
+          added: Number(latest?.new_count ?? 0),
+          message: latest?.status === "failed" ? String(latest?.error_info ?? "\u5907\u4EFD\u5931\u8D25") : "",
+          exitCode: latest?.status === "failed" ? 1 : 0
+        };
+      } finally {
+        db.close();
+      }
+    } catch {
+      return empty;
+    }
+  }
+};
+function parsedAddressText(value) {
+  if (value === void 0 || value === null) return "";
+  const items = Array.isArray(value) ? value : [value];
+  return formatAddressList(
+    items.map((item) => ({
+      name: String(item.name ?? ""),
+      address: String(item.address ?? "")
+    })).filter((address) => address.address !== "")
+  );
+}
+function addressTextOf(list) {
+  return (list ?? []).map((item) => {
+    const entry = item;
+    return entry.name ? `${entry.name} <${String(entry.address ?? "")}>` : String(entry.address ?? "");
+  }).filter((text2) => text2 !== "").join(", ");
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/host/http.ts
+var HttpError = class extends Error {
+  status;
+  code;
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+function sendJson(res, status, payload) {
+  const body = Buffer.from(JSON.stringify(payload), "utf8");
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.setHeader("content-length", String(body.length));
+  res.setHeader("cache-control", "no-store");
+  res.setHeader("x-content-type-options", "nosniff");
+  res.end(body);
+}
+async function readJsonBody(req, limit = 2 * 1024 * 1024) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > limit) throw new HttpError(413, "\u8BF7\u6C42\u4F53\u8FC7\u5927");
+    chunks.push(buffer);
+  }
+  if (size === 0) return {};
+  try {
+    const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new HttpError(400, "\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof HttpError) throw error;
+    throw new HttpError(400, "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5 JSON");
+  }
+}
+function isTrustedRequest(req) {
+  const origin = req.headers.origin;
+  if (origin === void 0 || origin === "") return true;
+  if (origin.startsWith("dsh-app://")) return true;
+  try {
+    const parsed = new URL(origin);
+    const host = req.headers.host ?? "";
+    return parsed.host === host;
+  } catch {
+    return false;
+  }
+}
+function assertTrusted(req) {
+  if (!isTrustedRequest(req)) throw new HttpError(403, "\u6765\u6E90\u4E0D\u88AB\u5141\u8BB8", "forbidden");
+}
+var Router = class {
+  routes = [];
+  add(method, path, handler) {
+    this.routes.push({
+      method: method.toUpperCase(),
+      segments: path.split("/").filter((segment) => segment !== ""),
+      handler
+    });
+  }
+  get(path, handler) {
+    this.add("GET", path, handler);
+  }
+  post(path, handler) {
+    this.add("POST", path, handler);
+  }
+  patch(path, handler) {
+    this.add("PATCH", path, handler);
+  }
+  delete(path, handler) {
+    this.add("DELETE", path, handler);
+  }
+  match(method, pathname) {
+    const parts = pathname.split("/").filter((segment) => segment !== "");
+    for (const route of this.routes) {
+      if (route.method !== method.toUpperCase()) continue;
+      if (route.segments.length !== parts.length) continue;
+      const params = {};
+      let matched = true;
+      for (const [index, segment] of route.segments.entries()) {
+        const actual = parts[index] ?? "";
+        if (segment.startsWith(":")) {
+          params[segment.slice(1)] = decodeURIComponent(actual);
+        } else if (segment !== actual) {
+          matched = false;
+          break;
+        }
+      }
+      if (matched) return { handler: route.handler, params, path: pathname };
+    }
+    return null;
+  }
+};
+
+// src/host/api.ts
+init_smtp();
+
+// src/host/html.ts
+function htmlToText(html) {
+  return html.replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|li|tr|h[1-6])>/gi, "\n").replace(/<li[^>]*>/gi, "\u2022 ").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{3,}/g, "\n\n").trim();
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+// src/host/api.ts
+var API_PREFIX = "/mail-plugin/api";
+function createApiHandler(runtime) {
+  const router = buildRouter(runtime);
+  return async function handler(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (!url.pathname.startsWith(API_PREFIX)) {
+      sendJson(res, 404, { error: "Not found" });
+      return;
+    }
+    const pathname = url.pathname.slice(API_PREFIX.length) || "/";
+    const method = (req.method ?? "GET").toUpperCase();
+    try {
+      if (method !== "GET" && method !== "HEAD") assertTrusted(req);
+      const match = router.match(method, pathname);
+      if (match === null) throw new HttpError(404, `\u672A\u77E5\u63A5\u53E3: ${method} ${pathname}`);
+      runtime.refresh();
+      const context = {
+        req,
+        res,
+        url,
+        params: match.params,
+        body: () => readJsonBody(req, method === "POST" && pathname === "/send" ? 25 * 1024 * 1024 : 2 * 1024 * 1024)
+      };
+      const result = await match.handler(context);
+      if (result !== void 0) sendJson(res, 200, result);
+    } catch (error) {
+      if (res.headersSent) {
+        res.end();
+        return;
+      }
+      sendJson(res, error instanceof HttpError ? error.status : 500, {
+        error: error instanceof Error ? error.message : String(error),
+        ...error instanceof HttpError && error.code !== void 0 ? { code: error.code } : {}
+      });
+    }
+  };
+}
+function buildRouter(runtime) {
+  const router = new Router();
+  router.get("/health", () => ({ ok: true, version: VERSION }));
+  router.get("/state", () => appState(runtime));
+  router.get("/folders", async ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    const source = sourceOf(url);
+    if (source === "server") {
+      const provider = runtime.provider(account);
+      const boxes = await provider.mailboxes();
+      return {
+        items: boxes.map((box) => ({ name: box.path, label: box.name, count: box.messages }))
+      };
+    }
+    return { items: runtime.database(account).mailboxes() };
+  });
+  router.get("/messages", async ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    const source = sourceOf(url);
+    const mailbox = url.searchParams.get("mailbox") ?? "all";
+    const query = url.searchParams.get("query") ?? "";
+    const offset = Number(url.searchParams.get("offset") ?? 0);
+    const limit = Number(url.searchParams.get("limit") ?? runtime.current.render.listLimit);
+    if (source === "server") {
+      const items = await listServer(runtime, account, mailbox, query, limit);
+      return { ...items, offset: 0, limit };
+    }
+    const db = runtime.database(account);
+    if (mailbox !== "all" && mailbox !== "") {
+      const page2 = db.list({ mailbox, query, offset, limit });
+      return { ...page2, items: page2.items.map((item) => localSummary(runtime, account, item)) };
+    }
+    const page = db.list({ mailbox: "all", query, offset, limit });
+    return { ...page, items: page.items.map((item) => localSummary(runtime, account, item)) };
+  });
+  router.get("/messages/:id", async ({ url, params }) => {
+    const { account } = accountFrom(runtime, url);
+    const source = sourceOf(url);
+    const mailbox = url.searchParams.get("mailbox") ?? "INBOX";
+    const id = params.id ?? "";
+    if (source === "server") {
+      const provider = runtime.provider(account);
+      const message = await provider.read(mailbox, Number(id));
+      return serverDetail(runtime, account, message, mailbox);
+    }
+    const detail = runtime.database(account).get(Number(id));
+    if (detail === void 0) throw new HttpError(404, "\u90AE\u4EF6\u4E0D\u5B58\u5728");
+    return localDetail(runtime, account, detail);
+  });
+  router.post("/messages/:id/read", async ({ url, params, body }) => {
+    const { account } = accountFrom(runtime, url);
+    const source = sourceOf(url);
+    const mailbox = url.searchParams.get("mailbox") ?? "INBOX";
+    const payload = await body();
+    const read = payload.read !== false;
+    if (source === "server") {
+      const provider = runtime.provider(account);
+      const result = await provider.setSeen(mailbox, Number(params.id), read);
+      return { ok: true, read: result.read };
+    }
+    const db = runtime.database(account);
+    const detail = db.get(Number(params.id));
+    if (detail === void 0) throw new HttpError(404, "\u90AE\u4EF6\u4E0D\u5B58\u5728");
+    const store = runtime.readState(account);
+    const key = detail.messageId !== "" ? `mid:${detail.messageId}` : `local:${detail.id}`;
+    store.setUnread(key, !read);
+    if (typeof detail.messageId === "string" && detail.messageId !== "") {
+      try {
+        const provider = runtime.provider(account);
+        const mailboxName = detail.mailbox === "" ? "INBOX" : detail.mailbox;
+        await provider.setSeenByMessageId(mailboxName, detail.messageId, read);
+      } catch {
+      }
+    }
+    return { ok: true, read };
+  });
+  router.get("/attachment", async ({ url, res }) => {
+    const { account } = accountFrom(runtime, url);
+    const source = sourceOf(url);
+    if (source === "server") {
+      const mailbox = url.searchParams.get("mailbox") ?? "INBOX";
+      const uid = Number(url.searchParams.get("uid") ?? 0);
+      const part = Number(url.searchParams.get("part") ?? 0);
+      const provider = runtime.provider(account);
+      const file2 = await provider.attachment(mailbox, uid, part);
+      writeAttachment(res, file2.filename, file2.contentType, Buffer.from(file2.dataBase64, "base64"));
+      return void 0;
+    }
+    const emailId = Number(url.searchParams.get("emailId") ?? 0);
+    const attachmentId = Number(url.searchParams.get("attachmentId") ?? 0);
+    const file = runtime.database(account).attachment(emailId, attachmentId);
+    if (file === void 0) throw new HttpError(404, "\u9644\u4EF6\u4E0D\u5B58\u5728");
+    writeAttachment(res, file.filename, file.contentType, Buffer.from(file.data));
+    return void 0;
+  });
+  router.get("/drafts", ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    return { items: runtime.drafts(account).list() };
+  });
+  router.post("/drafts", async ({ url, body }) => {
+    const { account } = accountFrom(runtime, url);
+    const payload = await body();
+    const draft = runtime.drafts(account).save(normalizeDraftInput(payload, account.id));
+    return { draft };
+  });
+  router.delete("/drafts/:id", ({ url, params }) => {
+    const { account } = accountFrom(runtime, url);
+    const removed = runtime.drafts(account).remove(params.id ?? "");
+    if (!removed) throw new HttpError(404, "\u8349\u7A3F\u4E0D\u5B58\u5728");
+    return { ok: true };
+  });
+  router.post("/send", async ({ url, body }) => {
+    const { account } = accountFrom(runtime, url);
+    const payload = await body();
+    const result = await sendFromPayload(runtime, account, payload);
+    return result;
+  });
+  router.get("/unread", async ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    if (!runtime.hasCredentials(account)) {
+      return { unread: runtime.readState(account).count(), source: "local" };
+    }
+    try {
+      const provider = runtime.provider(account);
+      const result = await provider.unseen();
+      return { unread: result.count, source: "server" };
+    } catch {
+      return { unread: runtime.readState(account).count(), source: "local" };
+    }
+  });
+  router.get("/accounts", () => ({ accounts: runtime.current.accounts }));
+  router.post("/accounts", async ({ body }) => {
+    const payload = await body();
+    const input = payload;
+    if (typeof input.email !== "string") throw new HttpError(400, "\u7F3A\u5C11\u90AE\u7BB1\u5730\u5740");
+    const password = typeof input.password === "string" ? input.password : "";
+    const config = runtime.current;
+    const account = buildAccount(input, config.accounts);
+    if (password === "") throw new HttpError(400, "\u8BF7\u8F93\u5165\u5BC6\u7801\u6216\u5E94\u7528\u4E13\u7528\u5BC6\u7801");
+    if (input.connect !== false) {
+      const provider = await verifyImap(account, password);
+      await provider.dispose();
+      try {
+        await verifySmtp(account.smtp, { user: account.username, pass: password });
+      } catch {
+      }
+    }
+    runtime.credentials.remember(account, password, input.remember !== false);
+    const accounts = [...config.accounts, account];
+    saveAccounts(accounts, account.id);
+    runtime.refresh();
+    return { account, state: appState(runtime) };
+  });
+  router.patch("/accounts/:id", async ({ params, body }) => {
+    const config = runtime.current;
+    const id = params.id ?? "";
+    const existing = config.accounts.find((account2) => account2.id === id);
+    if (existing === void 0) throw new HttpError(404, "\u8D26\u53F7\u4E0D\u5B58\u5728");
+    const payload = await body();
+    const merged = {
+      ...existing,
+      label: typeof payload.label === "string" ? payload.label : existing.label,
+      username: typeof payload.username === "string" ? payload.username : existing.username,
+      imap: { ...existing.imap, ...asObject(payload.imap) },
+      smtp: { ...existing.smtp, ...asObject(payload.smtp) },
+      caldav: payload.caldav === null ? null : payload.caldav === void 0 ? existing.caldav : { ...asObject(payload.caldav) },
+      enabled: payload.enabled === void 0 ? existing.enabled : payload.enabled !== false
+    };
+    const account = normalizeAccount(
+      merged,
+      0,
+      config.accounts.map((item) => item.id)
+    );
+    account.id = existing.id;
+    account.createdAt = existing.createdAt;
+    const accounts = config.accounts.map((item) => item.id === existing.id ? account : item);
+    saveAccounts(accounts, config.activeAccountId);
+    runtime.invalidate(existing.id);
+    return { account };
+  });
+  router.delete("/accounts/:id", ({ params }) => {
+    const config = runtime.current;
+    const id = params.id ?? "";
+    const accounts = config.accounts.filter((account) => account.id !== id);
+    if (accounts.length === config.accounts.length) throw new HttpError(404, "\u8D26\u53F7\u4E0D\u5B58\u5728");
+    const active = config.activeAccountId === id ? accounts[0]?.id ?? null : config.activeAccountId;
+    saveAccounts(accounts, active);
+    runtime.invalidate(id);
+    return { ok: true };
+  });
+  router.post("/accounts/:id/activate", ({ params }) => {
+    const config = runtime.current;
+    const id = params.id ?? "";
+    if (!config.accounts.some((account) => account.id === id)) throw new HttpError(404, "\u8D26\u53F7\u4E0D\u5B58\u5728");
+    saveAccounts(config.accounts, id);
+    runtime.refresh();
+    return { ok: true, activeAccountId: id };
+  });
+  router.post("/accounts/:id/login", async ({ params, body }) => {
+    const account = accountById(runtime, params.id);
+    const payload = await body();
+    const password = typeof payload.password === "string" ? payload.password : "";
+    if (password === "") throw new HttpError(400, "\u8BF7\u8F93\u5165\u5BC6\u7801\u6216\u5E94\u7528\u4E13\u7528\u5BC6\u7801");
+    const provider = await verifyImap(account, password);
+    await provider.dispose();
+    const stored = runtime.credentials.remember(account, password, payload.remember !== false);
+    return { ok: true, stored: stored.stored };
+  });
+  router.post("/accounts/:id/logout", ({ params }) => {
+    const account = accountById(runtime, params.id);
+    runtime.credentials.forget(account);
+    runtime.invalidate(account.id);
+    return { ok: true };
+  });
+  router.post("/accounts/:id/check", async ({ params }) => {
+    const account = accountById(runtime, params.id);
+    const provider = runtime.provider(account);
+    const imap = await provider.check();
+    let smtp = { ok: false };
+    try {
+      const credentials = runtime.credentialsFor(account);
+      await verifySmtp(account.smtp, credentials);
+      smtp = { ok: true };
+    } catch (error) {
+      smtp = { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    return { ok: true, imap, smtp };
+  });
+  router.get("/settings", () => settingsView(runtime.current));
+  router.patch("/settings", async ({ body }) => {
+    const payload = await body();
+    const patch = {};
+    if (typeof payload.signature === "string") patch.signature = payload.signature.slice(0, 5e3);
+    if (payload.ai !== void 0) patch.ai = asObject(payload.ai);
+    if (payload.read !== void 0) patch.read = asObject(payload.read);
+    if (payload.render !== void 0) patch.render = asObject(payload.render);
+    saveSettings(patch);
+    runtime.refresh();
+    return { settings: settingsView(runtime.current) };
+  });
+  router.get("/backup/status", ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    return runtime.backupStatus(account);
+  });
+  router.post("/backup/start", async ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    runtime.startBackup(account);
+    return { ok: true, status: runtime.backupStatus(account) };
+  });
+  router.post("/backup/stop", ({ url }) => {
+    const { account } = accountFrom(runtime, url);
+    const stopped = runtime.stopBackup(account);
+    return { ok: stopped, status: runtime.backupStatus(account) };
+  });
+  return router;
+}
+var VERSION = "0.1.0";
+function accountById(runtime, id) {
+  const account = runtime.current.accounts.find((item) => item.id === id);
+  if (account === void 0) throw new HttpError(404, "\u8D26\u53F7\u4E0D\u5B58\u5728");
+  return account;
+}
+function accountFrom(runtime, url) {
+  const requested = url.searchParams.get("accountId");
+  const config = runtime.current;
+  const account = requested === null || requested === "" || requested === "active" ? config.accounts.find((item) => item.id === config.activeAccountId) ?? config.accounts[0] : config.accounts.find((item) => item.id === requested);
+  if (account === void 0) throw new HttpError(400, "\u8BF7\u5148\u6DFB\u52A0\u4E00\u4E2A\u90AE\u7BB1\u8D26\u53F7");
+  return { account, config };
+}
+function sourceOf(url) {
+  return url.searchParams.get("source") === "server" ? "server" : "local";
+}
+async function verifyImap(account, password) {
+  const { ImapProvider: ImapProvider2 } = await Promise.resolve().then(() => (init_imap(), imap_exports));
+  const provider = new ImapProvider2(account.imap, { user: account.username || account.email, pass: password });
+  try {
+    await provider.check();
+    return provider;
+  } catch (error) {
+    await provider.dispose();
+    throw new HttpError(400, `\u8FDE\u63A5\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function appState(runtime) {
+  const config = runtime.current;
+  const account = config.accounts.find((item) => item.id === config.activeAccountId) ?? null;
+  return {
+    version: VERSION,
+    settings: settingsView(config),
+    accounts: config.accounts,
+    activeAccountId: config.activeAccountId,
+    backup: account === null ? emptyBackup() : runtime.backupStatus(account),
+    unread: account === null ? 0 : runtime.readState(account).count(),
+    loggedIn: account !== null && runtime.hasCredentials(account)
+  };
+}
+function emptyBackup() {
+  return {
+    running: false,
+    accountId: null,
+    startedAt: null,
+    finishedAt: null,
+    lastSuccessAt: null,
+    total: 0,
+    added: 0,
+    message: "",
+    output: [],
+    exitCode: null
+  };
+}
+function settingsView(config) {
+  return {
+    dataDir: config.dataDir,
+    configFile: config.configFile,
+    signature: config.signature,
+    accounts: config.accounts,
+    activeAccountId: config.activeAccountId,
+    ai: {
+      enabled: config.ai.enabled,
+      provider: config.ai.provider,
+      model: config.ai.model,
+      styleSampleCount: config.ai.styleSampleCount
+    },
+    read: { markOnOpen: config.read.markOnOpen, pollSeconds: config.read.pollSeconds },
+    render: { listLimit: config.render.listLimit }
+  };
+}
+function localSummary(runtime, account, row) {
+  const store = runtime.readState(account);
+  const key = row.messageId !== void 0 && row.messageId !== "" ? `mid:${row.messageId}` : `local:${row.id}`;
+  return { ...row, accountId: account.id, unread: store.isUnread(key), backedUp: true };
+}
+function localDetail(runtime, account, detail) {
+  return localSummary(runtime, account, detail);
+}
+function serverSummary(account, message, mailbox, backedUp) {
+  return {
+    id: String(message.uid),
+    accountId: account.id,
+    uid: message.uid,
+    messageId: message.messageId,
+    subject: message.subject,
+    from: message.from,
+    to: message.to,
+    date: message.date,
+    unread: !message.read,
+    flagged: false,
+    hasAttachments: false,
+    snippet: "",
+    size: message.size,
+    mailbox,
+    backedUp
+  };
+}
+function serverDetail(runtime, account, message, mailbox) {
+  let backedUp = false;
+  try {
+    backedUp = message.messageId !== "" && runtime.database(account).hasMessageId(message.messageId);
+  } catch {
+    backedUp = false;
+  }
+  return {
+    id: String(message.uid),
+    accountId: account.id,
+    uid: message.uid,
+    messageId: message.messageId,
+    subject: message.subject,
+    from: message.from,
+    to: message.to,
+    cc: message.cc,
+    replyTo: [],
+    date: message.date,
+    unread: !message.read,
+    flagged: false,
+    hasAttachments: message.attachments.length > 0,
+    snippet: "",
+    size: message.size,
+    mailbox,
+    backedUp,
+    text: message.text,
+    html: message.html,
+    attachments: message.attachments,
+    inReplyTo: message.inReplyTo,
+    references: message.references
+  };
+}
+async function listServer(runtime, account, mailbox, query, limit) {
+  const provider = runtime.provider(account);
+  const result = await provider.list(mailbox === "all" ? "INBOX" : mailbox, Math.min(200, limit * 2));
+  let database = null;
+  try {
+    database = runtime.database(account);
+  } catch {
+    database = null;
+  }
+  const text2 = query.trim().toLowerCase();
+  const items = result.items.filter((message) => {
+    if (text2 === "") return true;
+    return [message.subject, message.from.name, message.from.address, formatAddressList(message.to)].join(" ").toLowerCase().includes(text2);
+  }).slice(0, limit).map(
+    (message) => serverSummary(account, message, mailbox, database?.hasMessageId(message.messageId) ?? false)
+  );
+  return { items, total: result.total };
+}
+function writeAttachment(res, filename, contentType, data) {
+  res.statusCode = 200;
+  res.setHeader("content-type", contentType);
+  res.setHeader("content-length", String(data.length));
+  res.setHeader("content-disposition", `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`);
+  res.setHeader("cache-control", "no-store");
+  res.setHeader("x-content-type-options", "nosniff");
+  res.end(data);
+}
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizeDraftInput(payload, accountId) {
+  const attachments = Array.isArray(payload.attachments) ? payload.attachments.map((item) => asObject(item)).filter((item) => typeof item.filename === "string" && typeof item.data === "string").map((item) => ({
+    filename: String(item.filename),
+    contentType: typeof item.contentType === "string" ? item.contentType : "application/octet-stream",
+    data: String(item.data)
+  })) : [];
+  return {
+    ...typeof payload.id === "string" ? { id: payload.id } : {},
+    accountId,
+    to: stringOf(payload.to),
+    cc: stringOf(payload.cc),
+    bcc: stringOf(payload.bcc),
+    subject: stringOf(payload.subject),
+    html: stringOf(payload.html),
+    attachments,
+    ...typeof payload.inReplyTo === "string" ? { inReplyTo: payload.inReplyTo } : {},
+    ...typeof payload.references === "string" ? { references: payload.references } : {}
+  };
+}
+function stringOf(value) {
+  return typeof value === "string" ? value : "";
+}
+async function sendFromPayload(runtime, account, payload) {
+  const to = stringOf(payload.to);
+  if (to.trim() === "") throw new HttpError(400, "\u6536\u4EF6\u4EBA\u4E0D\u80FD\u4E3A\u7A7A");
+  const subject = stringOf(payload.subject);
+  const html = stringOf(payload.html);
+  const text2 = stringOf(payload.text) !== "" ? stringOf(payload.text) : htmlToText(html);
+  const attachments = Array.isArray(payload.attachments) ? payload.attachments.map((item) => asObject(item)).filter((item) => typeof item.filename === "string" && typeof item.data === "string").map((item) => ({
+    filename: String(item.filename),
+    contentType: typeof item.contentType === "string" && item.contentType !== "" ? item.contentType : "application/octet-stream",
+    content: Buffer.from(String(item.data), "base64")
+  })) : [];
+  const totalBytes = attachments.reduce((sum, file) => sum + file.content.length, 0);
+  if (totalBytes > 15 * 1024 * 1024) throw new HttpError(413, "\u9644\u4EF6\u5408\u8BA1\u4E0D\u80FD\u8D85\u8FC7 15 MB");
+  const { sendMail: sendMail2 } = await Promise.resolve().then(() => (init_smtp(), smtp_exports));
+  const signature = runtime.current.signature;
+  const bodyText = signature === "" ? text2 : `${text2}
+
+--
+${signature}`;
+  const bodyHtml = signature === "" ? html : `${html}<p>--</p><p>${escapeHtml(signature).replaceAll("\n", "<br>")}</p>`;
+  const result = await sendMail2(
+    account.smtp,
+    runtime.credentialsFor(account),
+    account.username || account.email,
+    {
+      to,
+      cc: stringOf(payload.cc),
+      subject,
+      text: bodyText,
+      html: bodyHtml,
+      ...typeof payload.inReplyTo === "string" ? { inReplyTo: payload.inReplyTo } : {},
+      ...typeof payload.references === "string" ? { references: payload.references } : {},
+      attachments
+    }
+  );
+  return { ok: true, result };
+}
+
+// src/host/runtime.ts
+import { statSync } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/host/secrets.ts
+import { spawnSync } from "node:child_process";
+function defaultRun(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: options.timeout ?? 1e4,
+    input: options.input,
+    stdio: options.input === void 0 ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"]
+  });
+  return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+function defaultHasCommand(command, args) {
+  const result = spawnSync(command, args, { timeout: 3e3, stdio: "ignore" });
+  return result.error === void 0 && result.status === 0;
+}
+function psString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+var SecretStore = class {
+  provider;
+  run;
+  hasCommand;
+  constructor(options = {}) {
+    const platform = options.platform ?? process.platform;
+    this.run = options.run ?? defaultRun;
+    this.hasCommand = options.hasCommand ?? defaultHasCommand;
+    if (platform === "darwin") {
+      this.provider = "macos";
+    } else if (platform === "win32") {
+      this.provider = this.hasCommand("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "exit 0"
+      ]) ? "windows" : "none";
+    } else if (platform === "linux") {
+      this.provider = this.hasCommand("secret-tool", ["--version"]) ? "libsecret" : "none";
+    } else {
+      this.provider = "none";
+    }
+  }
+  available() {
+    return this.provider !== "none";
+  }
+  read(service, account) {
+    if (service === "" || account === "") return void 0;
+    if (this.provider === "macos") {
+      const result = this.run("security", ["find-generic-password", "-s", service, "-a", account, "-w"]);
+      if (!result.ok) return void 0;
+      return trimSecret(result.stdout);
+    }
+    if (this.provider === "libsecret") {
+      const result = this.run("secret-tool", ["lookup", "service", service, "account", account]);
+      if (!result.ok) return void 0;
+      return trimSecret(result.stdout);
+    }
+    if (this.provider === "windows") {
+      const script = [
+        "$ErrorActionPreference = 'Stop'",
+        "[Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime] | Out-Null",
+        "$vault = New-Object Windows.Security.Credentials.PasswordVault",
+        `$resource = ${psString(service)}`,
+        `$user = ${psString(account)}`,
+        "$cred = $vault.FindAllByResource($resource) | Where-Object { $_.UserName -eq $user } | Select-Object -First 1",
+        "if ($null -eq $cred) { exit 1 }",
+        "$cred.RetrievePassword()",
+        "[Console]::Out.Write($cred.Password)"
+      ].join("\n");
+      const result = this.run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "-"], {
+        input: script
+      });
+      if (!result.ok) return void 0;
+      return trimSecret(result.stdout);
+    }
+    return void 0;
+  }
+  write(service, account, secret) {
+    if (service === "" || account === "" || secret === "") return false;
+    if (this.provider === "macos") {
+      return this.run("security", ["add-generic-password", "-U", "-s", service, "-a", account, "-w", secret]).ok;
+    }
+    if (this.provider === "libsecret") {
+      return this.run("secret-tool", ["store", "--label", service, "service", service, "account", account], {
+        input: secret
+      }).ok;
+    }
+    if (this.provider === "windows") {
+      const encoded = Buffer.from(secret, "utf8").toString("base64");
+      const script = [
+        "$ErrorActionPreference = 'Stop'",
+        "[Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime] | Out-Null",
+        "$vault = New-Object Windows.Security.Credentials.PasswordVault",
+        `$resource = ${psString(service)}`,
+        `$user = ${psString(account)}`,
+        `$password = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}'))`,
+        "$vault.FindAllByResource($resource) | Where-Object { $_.UserName -eq $user } | ForEach-Object { $vault.Remove($_) }",
+        "$vault.Add((New-Object Windows.Security.Credentials.PasswordCredential($resource, $user, $password)))"
+      ].join("\n");
+      return this.run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "-"], {
+        input: script
+      }).ok;
+    }
+    return false;
+  }
+  delete(service, account) {
+    if (service === "" || account === "") return false;
+    if (this.provider === "macos") {
+      return this.run("security", ["delete-generic-password", "-s", service, "-a", account]).ok;
+    }
+    if (this.provider === "libsecret") {
+      return this.run("secret-tool", ["clear", "service", service, "account", account]).ok;
+    }
+    if (this.provider === "windows") {
+      const script = [
+        "$ErrorActionPreference = 'Stop'",
+        "[Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime] | Out-Null",
+        "$vault = New-Object Windows.Security.Credentials.PasswordVault",
+        `$resource = ${psString(service)}`,
+        `$user = ${psString(account)}`,
+        "$vault.FindAllByResource($resource) | Where-Object { $_.UserName -eq $user } | ForEach-Object { $vault.Remove($_) }"
+      ].join("\n");
+      return this.run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "-"], {
+        input: script
+      }).ok;
+    }
+    return false;
+  }
+};
+function trimSecret(value) {
+  const text2 = value.replace(/\r?\n$/, "");
+  return text2 === "" ? void 0 : text2;
+}
+
+// src/host/accounts.ts
+function envKeyFor(account) {
+  const suffix = account.id.replace(/[^A-Za-z0-9]/g, "_").toUpperCase();
+  return `DSH_MAILHARBOR_PASSWORD_${suffix}`;
+}
+var CredentialManager = class {
+  session = /* @__PURE__ */ new Map();
+  secrets;
+  constructor(secrets = new SecretStore()) {
+    this.secrets = secrets;
+  }
+  get provider() {
+    return this.secrets.provider;
+  }
+  resolve(account) {
+    const session = this.session.get(account.id);
+    if (session !== void 0 && session !== "") return { password: session, source: "session" };
+    const fromEnv = process.env[envKeyFor(account)];
+    if (typeof fromEnv === "string" && fromEnv !== "") return { password: fromEnv, source: "env" };
+    const stored = this.secrets.read(account.keychainService, account.email);
+    if (stored !== void 0) return { password: stored, source: "keychain" };
+    return void 0;
+  }
+  /** Keep the password for this run and, when asked, for later runs. */
+  remember(account, password, persist) {
+    if (password === "") throw new Error("\u5BC6\u7801\u4E0D\u80FD\u4E3A\u7A7A");
+    this.session.set(account.id, password);
+    if (!persist) return { stored: false };
+    return { stored: this.secrets.write(account.keychainService, account.email, password) };
+  }
+  forget(account) {
+    this.session.delete(account.id);
+    this.secrets.delete(account.keychainService, account.email);
+  }
+  status(account) {
+    const resolved = this.resolve(account);
+    return {
+      hasPassword: resolved !== void 0,
+      source: resolved?.source ?? null,
+      provider: this.secrets.provider
+    };
+  }
+};
+
+// src/host/drafts.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+function text(value) {
+  return value === void 0 || value === null ? "" : String(value);
+}
+function isAttachment(value) {
+  return value !== null && typeof value === "object" && typeof value.filename === "string" && typeof value.data === "string";
+}
+function isDraft(value) {
+  return value !== null && typeof value === "object" && typeof value.id === "string";
+}
+function draftPath(root) {
+  return join3(root, "drafts.json");
+}
+var DraftStore = class {
+  file;
+  items = [];
+  accountId;
+  constructor(file, accountId) {
+    this.file = file;
+    this.accountId = accountId;
+    this.load();
+  }
+  load() {
+    try {
+      const parsed = JSON.parse(readFileSync3(this.file, "utf8"));
+      this.items = Array.isArray(parsed) ? parsed.filter(isDraft) : [];
+    } catch {
+      this.items = [];
+    }
+  }
+  flush() {
+    mkdirSync3(dirname(this.file), { recursive: true });
+    const temp = `${this.file}.${String(process.pid)}.${String(Date.now())}.tmp`;
+    writeFileSync3(temp, `${JSON.stringify(this.items, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    renameSync2(temp, this.file);
+  }
+  list() {
+    return [...this.items].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).map((draft) => ({ ...draft }));
+  }
+  get(id) {
+    const found = this.items.find((draft) => draft.id === id);
+    return found === void 0 ? void 0 : { ...found };
+  }
+  save(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = input.id === void 0 ? void 0 : this.items.find((draft2) => draft2.id === input.id);
+    const fields = {
+      to: text(input.to),
+      cc: text(input.cc),
+      bcc: text(input.bcc),
+      subject: text(input.subject),
+      html: text(input.html),
+      attachments: Array.isArray(input.attachments) ? input.attachments.filter(isAttachment).map((file) => ({
+        filename: text(file.filename).slice(0, 200),
+        contentType: text(file.contentType).slice(0, 160),
+        data: text(file.data)
+      })) : [],
+      inReplyTo: text(input.inReplyTo),
+      references: text(input.references)
+    };
+    if (existing !== void 0) {
+      Object.assign(existing, fields, { updatedAt: now });
+      this.flush();
+      return { ...existing };
+    }
+    const draft = {
+      id: randomUUID2(),
+      accountId: this.accountId,
+      ...fields,
+      updatedAt: now
+    };
+    this.items.push(draft);
+    this.flush();
+    return { ...draft };
+  }
+  remove(id) {
+    const index = this.items.findIndex((draft) => draft.id === id);
+    if (index < 0) return false;
+    this.items.splice(index, 1);
+    this.flush();
+    return true;
+  }
+  location() {
+    return this.file;
+  }
+};
+
+// src/host/runtime.ts
+init_imap();
+
+// src/host/read-state.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var ReadStateStore = class {
+  file;
+  keys = null;
+  constructor(file) {
+    this.file = file;
+  }
+  load() {
+    if (this.keys !== null) return this.keys;
+    try {
+      const parsed = JSON.parse(readFileSync4(this.file, "utf8"));
+      const list = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.unread) ? parsed.unread : [];
+      this.keys = new Set(list.filter((key) => typeof key === "string" && key !== ""));
+    } catch {
+      this.keys = /* @__PURE__ */ new Set();
+    }
+    return this.keys;
+  }
+  flush() {
+    mkdirSync4(dirname2(this.file), { recursive: true });
+    const temp = `${this.file}.${String(process.pid)}.tmp`;
+    writeFileSync4(temp, `${JSON.stringify({ unread: [...this.load()] }, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+    renameSync3(temp, this.file);
+  }
+  isUnread(key) {
+    return key !== "" && this.load().has(key);
+  }
+  setUnread(key, unread) {
+    const normalized = key.trim();
+    if (normalized === "") return false;
+    const keys = this.load();
+    const has = keys.has(normalized);
+    if (unread && !has) {
+      keys.add(normalized);
+      this.flush();
+      return true;
+    }
+    if (!unread && has) {
+      keys.delete(normalized);
+      this.flush();
+      return true;
+    }
+    return false;
+  }
+  sync(entries) {
+    let changed = false;
+    const keys = this.load();
+    for (const entry of entries) {
+      const key = String(entry.key ?? "").trim();
+      if (key === "") continue;
+      if (entry.unread && !keys.has(key)) {
+        keys.add(key);
+        changed = true;
+      } else if (!entry.unread && keys.has(key)) {
+        keys.delete(key);
+        changed = true;
+      }
+    }
+    if (changed) this.flush();
+  }
+  count() {
+    return this.load().size;
+  }
+  list() {
+    return [...this.load()];
+  }
+};
+
+// src/host/runtime.ts
+var MAX_OUTPUT_LINES = 200;
+var MailHarborRuntime = class {
+  config;
+  configStamp = 0;
+  credentials;
+  providers = /* @__PURE__ */ new Map();
+  databases = /* @__PURE__ */ new Map();
+  draftStores = /* @__PURE__ */ new Map();
+  readStores = /* @__PURE__ */ new Map();
+  backups = /* @__PURE__ */ new Map();
+  disposed = false;
+  constructor(options = {}) {
+    this.config = loadConfig();
+    this.credentials = options.credentials ?? new CredentialManager();
+  }
+  get current() {
+    return this.config;
+  }
+  /** Re-read the config file when it changed on disk. */
+  refresh() {
+    if (this.disposed) return this.config;
+    let stamp3 = 0;
+    try {
+      const stats = statSync(this.config.configFile);
+      stamp3 = stats.mtimeMs;
+    } catch {
+      stamp3 = 0;
+    }
+    if (stamp3 !== this.configStamp) {
+      this.configStamp = stamp3;
+      this.config = loadConfig();
+      this.prune();
+    }
+    return this.config;
+  }
+  prune() {
+    const live = new Set(this.config.accounts.map((account) => account.id));
+    for (const id of [...this.providers.keys()]) {
+      if (!live.has(id)) {
+        void this.providers.get(id)?.value.dispose();
+        this.providers.delete(id);
+      }
+    }
+    for (const id of [...this.databases.keys()]) {
+      if (!live.has(id)) {
+        this.databases.get(id)?.value.close();
+        this.databases.delete(id);
+      }
+    }
+    for (const id of [...this.draftStores.keys()]) if (!live.has(id)) this.draftStores.delete(id);
+    for (const id of [...this.readStores.keys()]) if (!live.has(id)) this.readStores.delete(id);
+  }
+  /** Drop cached connections and stores for one account after a settings change. */
+  invalidate(accountId) {
+    void this.providers.get(accountId)?.value.dispose();
+    this.providers.delete(accountId);
+    this.databases.get(accountId)?.value.close();
+    this.databases.delete(accountId);
+    this.draftStores.delete(accountId);
+    this.readStores.delete(accountId);
+    this.refresh();
+  }
+  active() {
+    return activeAccount(this.config);
+  }
+  account(id) {
+    return requireAccount(this.config, id);
+  }
+  paths(account) {
+    return accountRuntime(account);
+  }
+  /** Credentials for an account, with a clear message when the user must log in. */
+  credentialsFor(account) {
+    if (account.auth.type === "oauth2") {
+      throw new Error("OAuth2 \u8D26\u53F7\u6682\u672A\u5728\u6B64\u7248\u672C\u542F\u7528\uFF0C\u8BF7\u4F7F\u7528\u5E94\u7528\u4E13\u7528\u5BC6\u7801\u767B\u5F55");
+    }
+    const resolved = this.credentials.resolve(account);
+    if (resolved === void 0) throw new Error("\u8BF7\u5148\u767B\u5F55\u90AE\u7BB1\u8D26\u53F7");
+    return { user: account.username || account.email, pass: resolved.password };
+  }
+  hasCredentials(account) {
+    return this.credentials.resolve(account) !== void 0;
+  }
+  imapSettings(account) {
+    return account.imap;
+  }
+  provider(account) {
+    const signature = `${account.imap.host}:${String(account.imap.port)}:${String(account.imap.secure)}:${account.username}:${account.auth.type}`;
+    const existing = this.providers.get(account.id);
+    if (existing !== void 0 && existing.signature === signature) return existing.value;
+    if (existing !== void 0) void existing.value.dispose();
+    const created = new ImapProvider(account.imap, this.credentialsFor(account), {
+      onReconnect: () => {
+      }
+    });
+    this.providers.set(account.id, { signature, value: created });
+    return created;
+  }
+  database(account) {
+    const root = this.paths(account);
+    const existing = this.databases.get(account.id);
+    if (existing !== void 0 && existing.signature === root.mailDb) return existing.value;
+    if (existing !== void 0) existing.value.close();
+    const created = new MailDatabase(root.mailDb, {
+      maxBodyChars: 4e5,
+      attachmentsRoot: root.attachments
+    });
+    this.databases.set(account.id, { signature: root.mailDb, value: created });
+    return created;
+  }
+  drafts(account) {
+    const file = draftPath(this.paths(account).root);
+    const existing = this.draftStores.get(account.id);
+    if (existing !== void 0 && existing.signature === file) return existing.value;
+    const created = new DraftStore(file, account.id);
+    this.draftStores.set(account.id, { signature: file, value: created });
+    return created;
+  }
+  readState(account) {
+    const file = join4(this.paths(account).root, "read-state.json");
+    const existing = this.readStores.get(account.id);
+    if (existing !== void 0 && existing.signature === file) return existing.value;
+    const created = new ReadStateStore(file);
+    this.readStores.set(account.id, { signature: file, value: created });
+    return created;
+  }
+  backupStatus(account) {
+    const job = this.backups.get(account.id);
+    if (job !== void 0) return { ...job.status, output: [...job.status.output] };
+    const persisted = BackupEngine.status(this.paths(account).mailDb);
+    return { ...persisted, accountId: account.id };
+  }
+  /** Start an incremental backup; returns the job so the caller can stream output. */
+  startBackup(account, onEvent) {
+    const running = this.backups.get(account.id);
+    if (running !== void 0 && running.status.running) throw new Error("\u5907\u4EFD\u5DF2\u5728\u8FDB\u884C\u4E2D");
+    const controller = new AbortController();
+    const status = {
+      running: true,
+      accountId: account.id,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      finishedAt: null,
+      lastSuccessAt: null,
+      total: 0,
+      added: 0,
+      message: "\u51C6\u5907\u5907\u4EFD",
+      output: [],
+      exitCode: null
+    };
+    const job = { status, controller, promise: Promise.resolve() };
+    const engine = new BackupEngine(accountRuntime(account), this.credentialsFor(account));
+    job.promise = (async () => {
+      try {
+        const result = await engine.run({
+          signal: controller.signal,
+          onEvent: (event) => {
+            status.message = event.message;
+            if (event.mailbox !== void 0) status.message = event.message;
+            if (event.added !== void 0) status.added = event.added;
+            if (event.total !== void 0) status.total = event.total;
+            status.output.push(event.message);
+            if (status.output.length > MAX_OUTPUT_LINES)
+              status.output.splice(0, status.output.length - MAX_OUTPUT_LINES);
+            onEvent?.(event);
+          }
+        });
+        status.total = result.total;
+        status.added = result.newCount;
+        status.exitCode = 0;
+        status.message = `\u5907\u4EFD\u5B8C\u6210\uFF1A\u65B0\u589E ${String(result.newCount)} \u5C01\uFF0C\u5171 ${String(result.total)} \u5C01`;
+      } catch (error) {
+        status.exitCode = 1;
+        status.message = error instanceof Error ? error.message : String(error);
+        status.output.push(status.message);
+      } finally {
+        status.running = false;
+        status.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (status.exitCode === 0) status.lastSuccessAt = status.finishedAt;
+        this.databases.get(account.id)?.value.close();
+        this.databases.delete(account.id);
+      }
+    })();
+    this.backups.set(account.id, job);
+    return job;
+  }
+  stopBackup(account) {
+    const job = this.backups.get(account.id);
+    if (job === void 0 || !job.status.running) return false;
+    job.controller.abort();
+    return true;
+  }
+  async dispose() {
+    this.disposed = true;
+    for (const job of this.backups.values()) job.controller.abort();
+    for (const provider of this.providers.values()) await provider.value.dispose();
+    this.providers.clear();
+    for (const db of this.databases.values()) db.value.close();
+    this.databases.clear();
+  }
+};
+
+// src/host/tools.ts
+init_address();
+var MAX_BODY = 2e4;
+var MAX_LIST = 50;
+function textOf(args, key) {
+  if (args === null || typeof args !== "object") return "";
+  const value = args[key];
+  return typeof value === "string" ? value : "";
+}
+function numberOf(args, key) {
+  if (args === null || typeof args !== "object") return void 0;
+  const value = args[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clip(text2, max = MAX_BODY) {
+  return text2.length <= max ? text2 : `${text2.slice(0, max)}
+\u2026\uFF08\u5DF2\u622A\u65AD\uFF0C\u5171 ${text2.length} \u5B57\u7B26\uFF09`;
+}
+function line(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function stamp2(value) {
+  return value.slice(0, 19).replace("T", " ");
+}
+function summaryLine(item, index) {
+  const flags = [
+    item.backedUp === false ? "\u672A\u5907\u4EFD" : item.backedUp === true ? "\u5DF2\u5907\u4EFD" : "",
+    item.hasAttachments ? "\u6709\u9644\u4EF6" : "",
+    item.unread ? "\u672A\u8BFB" : ""
+  ].filter(Boolean);
+  return `${String(index + 1)}. [id=${item.id}] ${stamp2(item.date)} \xB7 ${line(item.from.name || item.from.address)} \xB7 ${line(item.subject)}${flags.length === 0 ? "" : ` \xB7 ${flags.join(" \xB7 ")}`}
+   ${item.snippet}`;
+}
+function plainSchema(properties, required = []) {
+  return { type: "object", properties, required, additionalProperties: false };
+}
+function textResult(_label, schema = { type: "string" }) {
+  return {
+    schema,
+    render: (_args, value) => [
+      { type: "text", text: typeof value === "string" ? value : JSON.stringify(value) }
+    ]
+  };
+}
+function tool(name2, description, parameters, output, execute) {
+  return {
+    name: name2,
+    description,
+    parameters,
+    output,
+    timeoutMs: 12e4,
+    isConcurrencySafe: () => true,
+    presentCall: (args) => ({ card: "generic", title: name2, kind: "read", rawInput: args }),
+    execute: async (args) => execute(args)
+  };
+}
+function registerMailTools(tools, runtime) {
+  const activeAccount2 = () => {
+    const account = runtime.active();
+    if (account === null) throw new Error("\u8BF7\u5148\u5728 MailHarbor \u9762\u677F\u91CC\u6DFB\u52A0\u4E00\u4E2A\u90AE\u7BB1\u8D26\u53F7");
+    return account;
+  };
+  const definitions = [
+    tool(
+      "mail_status",
+      "\u67E5\u770B\u90AE\u7BB1\u72B6\u6001\uFF1A\u8D26\u53F7\u3001\u662F\u5426\u5DF2\u767B\u5F55\u3001\u672C\u5730\u5907\u4EFD\u90AE\u4EF6\u6570\u3001\u4E0A\u6B21\u5907\u4EFD\u65F6\u95F4\u3002\u53EA\u8BFB\uFF0C\u4E0D\u4FEE\u6539\u4EFB\u4F55\u5185\u5BB9\u3002",
+      plainSchema({}),
+      textResult("\u72B6\u6001", {
+        type: "object",
+        properties: {
+          account: { type: "string" },
+          loggedIn: { type: "boolean" },
+          localTotal: { type: "number" },
+          lastBackup: { type: "string" },
+          backupRunning: { type: "boolean" }
+        },
+        required: ["account", "loggedIn", "localTotal"]
+      }),
+      async () => {
+        const account = activeAccount2();
+        const status = runtime.database(account).status();
+        const backup = runtime.backupStatus(account);
+        return {
+          account: account.email,
+          loggedIn: runtime.hasCredentials(account),
+          localTotal: status.total,
+          lastBackup: backup.lastSuccessAt ?? "",
+          backupRunning: backup.running
+        };
+      }
+    ),
+    tool(
+      "mail_list",
+      "\u5217\u51FA\u672C\u5730\u5907\u4EFD\u6216\u670D\u52A1\u5668\u4E0A\u7684\u90AE\u4EF6\u6458\u8981\u3002source=local \u8BFB\u672C\u5730\u5907\u4EFD\uFF08\u5FEB\u3001\u53EF\u641C\u7D22\uFF09\uFF0Csource=server \u8BFB\u670D\u52A1\u5668\u5B9E\u65F6\u3002",
+      plainSchema({
+        source: { type: "string", enum: ["local", "server"], description: "\u9ED8\u8BA4 local" },
+        mailbox: { type: "string", description: "\u90AE\u7BB1\u6587\u4EF6\u5939\u8DEF\u5F84\uFF0C\u9ED8\u8BA4 all\uFF08\u672C\u5730\uFF09\u6216 INBOX\uFF08\u670D\u52A1\u5668\uFF09" },
+        query: { type: "string", description: "\u5173\u952E\u8BCD\uFF0C\u4EC5\u672C\u5730\u641C\u7D22" },
+        limit: { type: "number", description: "\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u5C01\uFF0C\u9ED8\u8BA4 20\uFF0C\u6700\u5927 50" }
+      }),
+      textResult("\u90AE\u4EF6\u5217\u8868", {
+        type: "object",
+        properties: {
+          source: { type: "string" },
+          total: { type: "number" },
+          items: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                subject: { type: "string" },
+                from: { type: "string" },
+                date: { type: "string" },
+                unread: { type: "boolean" },
+                backedUp: { type: "boolean" }
+              },
+              required: ["id", "subject", "from", "date", "unread", "backedUp"]
+            }
+          },
+          text: { type: "string" }
+        },
+        required: ["source", "total", "items", "text"]
+      }),
+      async (args) => {
+        const account = activeAccount2();
+        const source = textOf(args, "source") === "server" ? "server" : "local";
+        const mailbox = textOf(args, "mailbox") !== "" ? textOf(args, "mailbox") : source === "server" ? "INBOX" : "all";
+        const limit = Math.min(MAX_LIST, Math.max(1, numberOf(args, "limit") ?? 20));
+        const query = textOf(args, "query");
+        let items = [];
+        let total = 0;
+        if (source === "server") {
+          const provider = runtime.provider(account);
+          const result = await provider.list(mailbox, limit);
+          total = result.total;
+          const db = runtime.database(account);
+          items = result.items.map((message) => ({
+            id: String(message.uid),
+            accountId: account.id,
+            uid: message.uid,
+            messageId: message.messageId,
+            subject: message.subject,
+            from: message.from,
+            to: message.to,
+            date: message.date,
+            unread: !message.read,
+            flagged: false,
+            hasAttachments: false,
+            snippet: "",
+            mailbox,
+            backedUp: message.messageId !== "" && db.hasMessageId(message.messageId)
+          }));
+        } else {
+          const page = runtime.database(account).list({
+            mailbox,
+            query,
+            limit,
+            offset: 0
+          });
+          total = page.total;
+          const readState = runtime.readState(account);
+          items = page.items.map((item) => ({
+            ...item,
+            accountId: account.id,
+            unread: item.messageId !== void 0 && item.messageId !== "" ? readState.isUnread(`mid:${item.messageId}`) : readState.isUnread(`local:${item.id}`),
+            backedUp: true
+          }));
+        }
+        const head = `${source === "server" ? "\u670D\u52A1\u5668\u5B9E\u65F6" : "\u672C\u5730\u5907\u4EFD"} \xB7 ${mailbox} \xB7 ${String(items.length)}/${String(total)} \u5C01`;
+        return {
+          source,
+          total,
+          items: items.map((item) => ({
+            id: item.id,
+            subject: item.subject,
+            from: item.from.name || item.from.address,
+            date: stamp2(item.date),
+            unread: item.unread,
+            backedUp: item.backedUp ?? true
+          })),
+          text: items.length === 0 ? `${head}
+\uFF08\u6CA1\u6709\u90AE\u4EF6\uFF09` : `${head}
+
+${items.map(summaryLine).join("\n")}`
+        };
+      }
+    ),
+    tool(
+      "mail_read",
+      "\u8BFB\u53D6\u4E00\u5C01\u90AE\u4EF6\u7684\u5168\u6587\u3002\u672C\u5730\u5907\u4EFD\u7528 id\uFF1B\u670D\u52A1\u5668\u90AE\u4EF6\u7528 uid \u5E76\u4F20 source=server\u3001mailbox\u3002",
+      plainSchema(
+        {
+          id: { type: "string", description: "\u672C\u5730\u90AE\u4EF6 id \u6216\u670D\u52A1\u5668 uid" },
+          source: { type: "string", enum: ["local", "server"], description: "\u9ED8\u8BA4 local" },
+          mailbox: { type: "string", description: "\u670D\u52A1\u5668\u6587\u4EF6\u5939\u8DEF\u5F84\uFF0C\u9ED8\u8BA4 INBOX" }
+        },
+        ["id"]
+      ),
+      textResult("\u90AE\u4EF6\u5168\u6587", {
+        type: "object",
+        properties: {
+          subject: { type: "string" },
+          from: { type: "string" },
+          date: { type: "string" },
+          text: { type: "string" },
+          attachments: { type: "array", items: { type: "object" } }
+        },
+        required: ["subject", "from", "date", "text", "attachments"]
+      }),
+      async (args) => {
+        const account = activeAccount2();
+        const id = textOf(args, "id");
+        if (id === "") throw new Error("\u7F3A\u5C11\u90AE\u4EF6 id");
+        const source = textOf(args, "source") === "server" ? "server" : "local";
+        if (source === "server") {
+          const mailbox = textOf(args, "mailbox") !== "" ? textOf(args, "mailbox") : "INBOX";
+          const message = await runtime.provider(account).read(mailbox, Number(id));
+          const detail2 = {
+            ...message,
+            id: String(message.uid),
+            accountId: account.id,
+            cc: message.cc,
+            replyTo: [],
+            unread: !message.read,
+            flagged: false,
+            hasAttachments: message.attachments.length > 0,
+            snippet: "",
+            mailbox,
+            backedUp: message.messageId !== "" && runtime.database(account).hasMessageId(message.messageId)
+          };
+          return {
+            subject: detail2.subject,
+            from: `${detail2.from.name} <${detail2.from.address}>`.trim(),
+            date: stamp2(detail2.date),
+            text: clip(detail2.text),
+            attachments: detail2.attachments.map((file) => ({
+              filename: file.filename,
+              contentType: file.contentType,
+              size: file.size
+            }))
+          };
+        }
+        const detail = runtime.database(account).get(Number(id));
+        if (detail === void 0) throw new Error("\u90AE\u4EF6\u4E0D\u5B58\u5728");
+        return {
+          subject: detail.subject,
+          from: `${detail.from.name} <${detail.from.address}>`.trim(),
+          date: stamp2(detail.date),
+          text: clip(detail.text),
+          attachments: detail.attachments.map((file) => ({
+            filename: file.filename,
+            contentType: file.contentType,
+            size: file.size
+          }))
+        };
+      }
+    ),
+    tool(
+      "mail_search",
+      "\u5728\u672C\u5730\u5907\u4EFD\u4E2D\u5168\u6587\u641C\u7D22\uFF08\u4E3B\u9898\u3001\u53D1\u4EF6\u4EBA\u3001\u6536\u4EF6\u4EBA\u3001\u6B63\u6587\u3001\u9644\u4EF6\u540D\uFF09\u3002\u53EA\u8BFB\u3002",
+      plainSchema(
+        {
+          query: { type: "string", description: "\u641C\u7D22\u5173\u952E\u8BCD" },
+          limit: { type: "number", description: "\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u5C01\uFF0C\u9ED8\u8BA4 20" }
+        },
+        ["query"]
+      ),
+      textResult("\u641C\u7D22\u7ED3\u679C"),
+      async (args) => {
+        const account = activeAccount2();
+        const query = textOf(args, "query");
+        if (query === "") throw new Error("\u7F3A\u5C11\u641C\u7D22\u5173\u952E\u8BCD");
+        const limit = Math.min(MAX_LIST, Math.max(1, numberOf(args, "limit") ?? 20));
+        const page = runtime.database(account).list({ mailbox: "all", query, limit, offset: 0 });
+        const readState = runtime.readState(account);
+        return page.items.length === 0 ? `\u6CA1\u6709\u5339\u914D\u300C${query}\u300D\u7684\u90AE\u4EF6` : `\u641C\u7D22\u300C${query}\u300D\uFF1A${String(page.total)} \u5C01\u4E2D\u524D ${String(page.items.length)} \u5C01
+
+${page.items.map(
+          (item, index) => summaryLine(
+            {
+              ...item,
+              accountId: account.id,
+              unread: readState.isUnread(`local:${item.id}`),
+              backedUp: true
+            },
+            index
+          )
+        ).join("\n")}`;
+      }
+    ),
+    tool(
+      "mail_drafts",
+      "\u5217\u51FA\u5F53\u524D\u8D26\u53F7\u7684\u8349\u7A3F\u3002\u53EA\u8BFB\uFF0C\u4E0D\u4F1A\u53D1\u9001\u3002",
+      plainSchema({}),
+      textResult("\u8349\u7A3F\u5217\u8868", {
+        type: "object",
+        properties: { drafts: { type: "array", items: { type: "object" } }, text: { type: "string" } },
+        required: ["drafts", "text"]
+      }),
+      async () => {
+        const account = activeAccount2();
+        const drafts = runtime.drafts(account).list().map((draft) => ({
+          id: draft.id,
+          subject: draft.subject,
+          to: draft.to,
+          updatedAt: draft.updatedAt
+        }));
+        return {
+          drafts,
+          text: drafts.length === 0 ? "\uFF08\u6CA1\u6709\u8349\u7A3F\uFF09" : drafts.map(
+            (draft, index) => `${String(index + 1)}. [${draft.id}] ${stamp2(draft.updatedAt)} \xB7 \u2192 ${line(draft.to)} \xB7 ${line(draft.subject)}`
+          ).join("\n")
+        };
+      }
+    ),
+    tool(
+      "mail_draft",
+      "\u65B0\u5EFA\u6216\u66F4\u65B0\u4E00\u5C01\u8349\u7A3F\u3002\u53EA\u5199\u672C\u5730\u8349\u7A3F\uFF0C\u4E0D\u4F1A\u53D1\u9001\uFF1B\u53D1\u9001\u4ECD\u9700\u7528\u6237\u5728\u9762\u677F\u91CC\u786E\u8BA4\u3002",
+      plainSchema(
+        {
+          id: { type: "string", description: "\u66F4\u65B0\u5DF2\u6709\u8349\u7A3F\u65F6\u4F20\u5165" },
+          to: { type: "string" },
+          cc: { type: "string" },
+          bcc: { type: "string" },
+          subject: { type: "string" },
+          html: { type: "string", description: "\u6B63\u6587 HTML" },
+          inReplyTo: { type: "string" },
+          references: { type: "string" }
+        },
+        ["subject"]
+      ),
+      textResult("\u8349\u7A3F", {
+        type: "object",
+        properties: { id: { type: "string" }, subject: { type: "string" }, updatedAt: { type: "string" } },
+        required: ["id", "subject", "updatedAt"]
+      }),
+      async (args) => {
+        const account = activeAccount2();
+        const draft = runtime.drafts(account).save({
+          ...textOf(args, "id") !== "" ? { id: textOf(args, "id") } : {},
+          to: textOf(args, "to"),
+          cc: textOf(args, "cc"),
+          bcc: textOf(args, "bcc"),
+          subject: textOf(args, "subject"),
+          html: textOf(args, "html"),
+          inReplyTo: textOf(args, "inReplyTo"),
+          references: textOf(args, "references")
+        });
+        return { id: draft.id, subject: draft.subject, updatedAt: draft.updatedAt };
+      }
+    ),
+    tool(
+      "mail_backup",
+      "\u89E6\u53D1\u4E00\u6B21\u589E\u91CF\u5907\u4EFD\uFF08\u540E\u53F0\u6267\u884C\uFF09\u3002\u5907\u4EFD\u4F1A\u8BFB\u53D6\u670D\u52A1\u5668\u4E0A\u7684\u5168\u90E8\u90AE\u4EF6\uFF0C\u53EF\u80FD\u6301\u7EED\u51E0\u5206\u949F\uFF1B\u53EA\u5728\u7528\u6237\u660E\u786E\u8981\u6C42\u65F6\u8C03\u7528\u3002",
+      plainSchema({}),
+      textResult("\u5907\u4EFD\u72B6\u6001", {
+        type: "object",
+        properties: { started: { type: "boolean" }, message: { type: "string" } },
+        required: ["started", "message"]
+      }),
+      async () => {
+        const account = activeAccount2();
+        try {
+          runtime.startBackup(account);
+          return { started: true, message: "\u5907\u4EFD\u5DF2\u5728\u540E\u53F0\u5F00\u59CB\uFF0C\u8FDB\u5EA6\u53EF\u5728\u9762\u677F\u7684\u5907\u4EFD\u5F39\u7A97\u67E5\u770B" };
+        } catch (error) {
+          return { started: false, message: error instanceof Error ? error.message : String(error) };
+        }
+      }
+    )
+  ];
+  return definitions.map((definition) => tools.register(definition));
+}
+
+// src/host/index.ts
+var name = "mailharbor";
+var inject = ["webServer", "tools"];
+var VERSION2 = "0.2.0";
+var ROUTE = "/mail-plugin";
+function apply(ctx) {
+  const runtime = new MailHarborRuntime();
+  const handler = createApiHandler(runtime);
+  const disposers = [];
+  const start = () => {
+    disposers.push(ctx.webServer.register({ kind: "prefix", path: ROUTE, handler }));
+    if (ctx.tools !== void 0) disposers.push(...registerMailTools(ctx.tools, runtime));
+  };
+  const stop = () => {
+    for (const dispose of disposers.splice(0)) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    void runtime.dispose();
+  };
+  if (typeof ctx.effect === "function") {
+    ctx.effect(() => {
+      start();
+      return stop;
+    }, "mailharbor: routes and tools");
+  } else {
+    start();
+  }
+}
+export {
+  VERSION2 as VERSION,
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=index.js.map