hypermail-mcp 0.7.3 → 0.7.5

package/dist/cli.js

@@ -170,29 +170,6 @@ var AccountStore = class _AccountStore {
 
 // src/providers/outlook/index.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join as pathJoin } from "path";
-import { ResponseType } from "@microsoft/microsoft-graph-client";
-
-// src/providers/shared/inline-images.ts
-import { randomUUID } from "crypto";
-function parseInlineImages(html) {
-  const images = [];
-  const re = /src="data:image\/([\w+]+);base64,([^"]+)"/gi;
-  const transformed = html.replace(re, (_fullMatch, mimeSubtype, b64) => {
-    const contentId = `sig-img-${randomUUID()}`;
-    const ext = mimeSubtype.toLowerCase().replace(/\+/g, "-") === "svg-xml" ? "svg" : mimeSubtype.toLowerCase().replace(/\+/g, "-");
-    images.push({
-      cid: contentId,
-      contentBytes: b64,
-      contentType: `image/${mimeSubtype}`,
-      filename: `signature-image.${ext}`
-    });
-    return `src="cid:${contentId}"`;
-  });
-  return { body: transformed, images };
-}
 
 // src/providers/outlook/client.ts
 import "isomorphic-fetch";
@@ -406,7 +383,26 @@ var OutlookClientFactory = class {
   }
 };
 
-// src/providers/outlook/index.ts
+// src/providers/shared/inline-images.ts
+import { randomUUID } from "crypto";
+function parseInlineImages(html) {
+  const images = [];
+  const re = /src="data:image\/([\w+]+);base64,([^"]+)"/gi;
+  const transformed = html.replace(re, (_fullMatch, mimeSubtype, b64) => {
+    const contentId = `sig-img-${randomUUID()}`;
+    const ext = mimeSubtype.toLowerCase().replace(/\+/g, "-") === "svg-xml" ? "svg" : mimeSubtype.toLowerCase().replace(/\+/g, "-");
+    images.push({
+      cid: contentId,
+      contentBytes: b64,
+      contentType: `image/${mimeSubtype}`,
+      filename: `signature-image.${ext}`
+    });
+    return `src="cid:${contentId}"`;
+  });
+  return { body: transformed, images };
+}
+
+// src/providers/outlook/helpers.ts
 function convertInlineImages(body) {
   const { body: transformed, images } = parseInlineImages(body);
   const attachments = images.map((img) => ({
@@ -419,6 +415,300 @@ function convertInlineImages(body) {
   }));
   return { body: transformed, attachments };
 }
+function mapFolder(f) {
+  return {
+    id: f.id,
+    displayName: f.displayName,
+    parentFolderId: f.parentFolderId,
+    childFolderCount: f.childFolderCount,
+    totalItemCount: f.totalItemCount,
+    unreadItemCount: f.unreadItemCount
+  };
+}
+function mapRecipient(r) {
+  return {
+    name: r.emailAddress?.name,
+    address: r.emailAddress?.address ?? ""
+  };
+}
+function mapSummary(m, folder) {
+  return {
+    id: m.id,
+    subject: m.subject ?? "",
+    from: m.from ? mapRecipient(m.from) : void 0,
+    to: (m.toRecipients ?? []).map(mapRecipient),
+    receivedAt: m.receivedDateTime,
+    preview: m.bodyPreview,
+    isRead: m.isRead,
+    hasAttachments: m.hasAttachments,
+    folder
+  };
+}
+function toRecipient(a) {
+  return { emailAddress: { name: a.name, address: a.address } };
+}
+function clampLimit(v, dflt, max) {
+  if (!v || v <= 0) return dflt;
+  return Math.min(v, max);
+}
+
+// src/providers/outlook/write-ops.ts
+var THREAD_MARKER = "<!-- hypermail-thread-boundary -->";
+async function buildDraftFromReference(client, createEndpoint, createPayload, converted) {
+  const draft = await client.api(createEndpoint).post(createPayload);
+  const draftMsg = await client.api(`/me/messages/${draft.id}`).select("body").get();
+  const draftBody = draftMsg.body?.content ?? "";
+  const draftContentType = draftMsg.body?.contentType ?? "HTML";
+  const spacer = '<div style="line-height:12px"><br></div>';
+  const prepend = converted.body + spacer + THREAD_MARKER;
+  const finalBody = draftBody.includes("<body") ? draftBody.replace(/(<body[^>]*>)/i, `$1${prepend}`) : prepend + draftBody;
+  await client.api(`/me/messages/${draft.id}`).patch({
+    body: { contentType: draftContentType, content: finalBody }
+  });
+  for (const att of converted.attachments) {
+    await client.api(`/me/messages/${draft.id}/attachments`).post(att);
+  }
+  return draft.id;
+}
+async function sendOrSave(client, account, msg, mode) {
+  const converted = convertInlineImages(msg.body);
+  const toRecipients = msg.to.map(toRecipient);
+  const ccRecipients = (msg.cc ?? []).map(toRecipient);
+  const bccRecipients = (msg.bcc ?? []).map(toRecipient);
+  if (msg.forwardMessageId) {
+    const draftId = await buildDraftFromReference(
+      client,
+      `/me/messages/${encodeURIComponent(msg.forwardMessageId)}/createForward`,
+      { message: { toRecipients, ccRecipients, bccRecipients }, comment: "" },
+      converted
+    );
+    if (mode === "send") {
+      await client.api(`/me/messages/${draftId}/send`).post({});
+    }
+    return { id: draftId };
+  }
+  if (msg.inReplyTo) {
+    const createEndpoint = msg.replyAll ? `/me/messages/${encodeURIComponent(msg.inReplyTo)}/createReplyAll` : `/me/messages/${encodeURIComponent(msg.inReplyTo)}/createReply`;
+    const draftId = await buildDraftFromReference(
+      client,
+      createEndpoint,
+      {},
+      converted
+    );
+    if (mode === "send") {
+      await client.api(`/me/messages/${draftId}/send`).post({});
+    }
+    return { id: draftId };
+  }
+  const messagePayload = {
+    subject: msg.subject,
+    body: {
+      contentType: msg.isHtml ? "HTML" : "Text",
+      content: converted.body
+    },
+    toRecipients,
+    ccRecipients,
+    bccRecipients
+  };
+  const allAttachments = [...converted.attachments];
+  if (msg.attachments && msg.attachments.length > 0) {
+    for (const att of msg.attachments) {
+      allAttachments.push({
+        "@odata.type": "#microsoft.graph.fileAttachment",
+        name: att.name,
+        contentBytes: att.contentBytes,
+        contentType: att.contentType ?? "application/octet-stream"
+      });
+    }
+  }
+  if (allAttachments.length > 0) {
+    messagePayload.attachments = allAttachments;
+  }
+  if (mode === "send") {
+    await client.api("/me/sendMail").post({
+      message: messagePayload,
+      saveToSentItems: true
+    });
+    return { id: "" };
+  }
+  const draft = await client.api("/me/messages").post(messagePayload);
+  return { id: draft.id };
+}
+async function updateDraft(client, account, id, update) {
+  const payload = {};
+  if (update.subject !== void 0) {
+    payload.subject = update.subject;
+  }
+  if (update.to !== void 0) {
+    payload.toRecipients = update.to.map(toRecipient);
+  }
+  if (update.cc !== void 0) {
+    payload.ccRecipients = update.cc.map(toRecipient);
+  }
+  if (update.bcc !== void 0) {
+    payload.bccRecipients = update.bcc.map(toRecipient);
+  }
+  if (update.body !== void 0) {
+    const converted = convertInlineImages(update.body);
+    payload.body = {
+      contentType: update.isHtml ? "HTML" : "Text",
+      content: converted.body
+    };
+    if (converted.attachments.length > 0) {
+      payload.attachments = converted.attachments;
+    }
+  }
+  await client.api(`/me/messages/${encodeURIComponent(id)}`).patch(payload);
+  return { id };
+}
+async function addAttachmentToDraft(client, account, draftId, name, contentBytes, contentType) {
+  const att = await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments`).post({
+    "@odata.type": "#microsoft.graph.fileAttachment",
+    name,
+    contentType: contentType ?? "application/octet-stream",
+    contentBytes
+  });
+  return {
+    id: draftId,
+    attachment: { id: att.id, name: att.name, contentType: att.contentType }
+  };
+}
+async function removeAttachmentFromDraft(client, account, draftId, attachmentId) {
+  await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments/${encodeURIComponent(attachmentId)}`).delete();
+}
+async function moveEmail(client, account, id, destinationId) {
+  await client.api(`/me/messages/${encodeURIComponent(id)}/move`).post({ destinationId });
+}
+async function sendDraft(client, account, id) {
+  await client.api(`/me/messages/${encodeURIComponent(id)}/send`).post({});
+  return { id };
+}
+async function markRead(client, account, id, isRead) {
+  await client.api(`/me/messages/${encodeURIComponent(id)}`).patch({ isRead });
+}
+
+// src/providers/outlook/read-ops.ts
+import { ResponseType } from "@microsoft/microsoft-graph-client";
+import { writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as pathJoin } from "path";
+async function listEmails(client, account, opts) {
+  const limit = clampLimit(opts.limit, 25, 100);
+  const folder = opts.folder ?? "inbox";
+  const filterParts = [];
+  if (opts.unreadOnly) filterParts.push("isRead eq false");
+  let req = client.api(`/me/mailFolders/${encodeURIComponent(folder)}/messages`).top(limit).skip(opts.skip ?? 0).select([
+    "id",
+    "subject",
+    "from",
+    "toRecipients",
+    "receivedDateTime",
+    "bodyPreview",
+    "isRead",
+    "hasAttachments"
+  ].join(",")).orderby("receivedDateTime DESC");
+  if (filterParts.length > 0) req = req.filter(filterParts.join(" and "));
+  const res = await req.get();
+  return {
+    items: res.value.map((m) => mapSummary(m, folder)),
+    hasMore: !!res["@odata.nextLink"]
+  };
+}
+async function searchEmails(client, account, query, opts) {
+  const limit = clampLimit(opts.limit, 25, 100);
+  const res = await client.api("/me/messages").header("ConsistencyLevel", "eventual").top(limit).search(`"${query.replace(/"/g, '\\"')}"`).select(
+    [
+      "id",
+      "subject",
+      "from",
+      "toRecipients",
+      "receivedDateTime",
+      "bodyPreview",
+      "isRead",
+      "hasAttachments"
+    ].join(",")
+  ).get();
+  return res.value.map((m) => mapSummary(m));
+}
+async function readEmail(client, account, id) {
+  const m = await client.api(`/me/messages/${encodeURIComponent(id)}`).select(
+    [
+      "id",
+      "subject",
+      "from",
+      "toRecipients",
+      "ccRecipients",
+      "bccRecipients",
+      "receivedDateTime",
+      "bodyPreview",
+      "isRead",
+      "hasAttachments",
+      "body"
+    ].join(",")
+  ).get();
+  let attachments = void 0;
+  if (m.hasAttachments) {
+    try {
+      const attRes = await client.api(`/me/messages/${encodeURIComponent(id)}/attachments`).select("id,name,contentType,size").get();
+      attachments = attRes.value.map((a) => ({
+        id: a.id,
+        name: a.name,
+        contentType: a.contentType,
+        size: a.size
+      }));
+    } catch {
+    }
+  }
+  const summary = mapSummary(m);
+  const body = m.body;
+  return {
+    ...summary,
+    cc: (m.ccRecipients ?? []).map(mapRecipient),
+    bcc: (m.bccRecipients ?? []).map(mapRecipient),
+    bodyText: body?.contentType === "text" ? body.content : void 0,
+    bodyHtml: body?.contentType === "html" ? body.content : void 0,
+    attachments
+  };
+}
+async function readAttachment(client, account, messageId, attachmentId) {
+  const att = await client.api(`/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`).select("name,contentType").get();
+  const data = await client.api(`/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}/$value`).responseType(ResponseType.ARRAYBUFFER).get();
+  const outPath = pathJoin(tmpdir(), att.name);
+  writeFileSync(outPath, Buffer.from(data));
+  return {
+    name: att.name,
+    contentType: att.contentType,
+    path: outPath
+  };
+}
+
+// src/providers/outlook/folders.ts
+async function listFolders(client, account, opts) {
+  const endpoint = opts.parentFolderId ? `/me/mailFolders/${encodeURIComponent(opts.parentFolderId)}/childFolders` : "/me/mailFolders";
+  const res = await client.api(endpoint).select([
+    "id",
+    "displayName",
+    "parentFolderId",
+    "childFolderCount",
+    "totalItemCount",
+    "unreadItemCount"
+  ].join(",")).get();
+  return (res.value ?? []).map(mapFolder);
+}
+async function createFolder(client, account, input) {
+  const parentId = input.parentFolderId ?? "msgfolderroot";
+  const created = await client.api(`/me/mailFolders/${encodeURIComponent(parentId)}/childFolders`).post({ displayName: input.displayName });
+  return mapFolder(created);
+}
+async function renameFolder(client, account, folderId, newName) {
+  const updated = await client.api(`/me/mailFolders/${encodeURIComponent(folderId)}`).patch({ displayName: newName });
+  return mapFolder(updated);
+}
+async function deleteFolder(client, account, folderId) {
+  await client.api(`/me/mailFolders/${encodeURIComponent(folderId)}`).delete();
+}
+
+// src/providers/outlook/index.ts
 var OutlookProvider = class {
   constructor(opts) {
     this.opts = opts;
@@ -497,301 +787,64 @@ var OutlookProvider = class {
     }
     return { status: "pending" };
   }
-  // ---------- email ops ----------
+  // ---------- email ops (delegated) ----------
   async listEmails(account, opts) {
-    const client = this.clients.get(account);
-    const limit = clampLimit(opts.limit, 25, 100);
-    const folder = opts.folder ?? "inbox";
-    const filterParts = [];
-    if (opts.unreadOnly) filterParts.push("isRead eq false");
-    let req = client.api(`/me/mailFolders/${encodeURIComponent(folder)}/messages`).top(limit).skip(opts.skip ?? 0).select([
-      "id",
-      "subject",
-      "from",
-      "toRecipients",
-      "receivedDateTime",
-      "bodyPreview",
-      "isRead",
-      "hasAttachments"
-    ].join(",")).orderby("receivedDateTime DESC");
-    if (filterParts.length > 0) req = req.filter(filterParts.join(" and "));
-    const res = await req.get();
-    return {
-      items: res.value.map((m) => mapSummary(m, folder)),
-      hasMore: !!res["@odata.nextLink"]
-    };
+    return listEmails(this.clients.get(account), account, opts);
   }
   async searchEmails(account, query, opts) {
-    const client = this.clients.get(account);
-    const limit = clampLimit(opts.limit, 25, 100);
-    const res = await client.api("/me/messages").header("ConsistencyLevel", "eventual").top(limit).search(`"${query.replace(/"/g, '\\"')}"`).select(
-      [
-        "id",
-        "subject",
-        "from",
-        "toRecipients",
-        "receivedDateTime",
-        "bodyPreview",
-        "isRead",
-        "hasAttachments"
-      ].join(",")
-    ).get();
-    return res.value.map((m) => mapSummary(m));
+    return searchEmails(this.clients.get(account), account, query, opts);
   }
   async readEmail(account, id) {
-    const client = this.clients.get(account);
-    const m = await client.api(`/me/messages/${encodeURIComponent(id)}`).select(
-      [
-        "id",
-        "subject",
-        "from",
-        "toRecipients",
-        "ccRecipients",
-        "bccRecipients",
-        "receivedDateTime",
-        "bodyPreview",
-        "isRead",
-        "hasAttachments",
-        "body"
-      ].join(",")
-    ).get();
-    let attachments = void 0;
-    if (m.hasAttachments) {
-      try {
-        const attRes = await client.api(`/me/messages/${encodeURIComponent(id)}/attachments`).select("id,name,contentType,size").get();
-        attachments = attRes.value.map((a) => ({
-          id: a.id,
-          name: a.name,
-          contentType: a.contentType,
-          size: a.size
-        }));
-      } catch {
-      }
-    }
-    const summary = mapSummary(m);
-    const body = m.body;
-    return {
-      ...summary,
-      cc: (m.ccRecipients ?? []).map(mapRecipient),
-      bcc: (m.bccRecipients ?? []).map(mapRecipient),
-      bodyText: body?.contentType === "text" ? body.content : void 0,
-      bodyHtml: body?.contentType === "html" ? body.content : void 0,
-      attachments
-    };
+    return readEmail(this.clients.get(account), account, id);
   }
   async readAttachment(account, messageId, attachmentId) {
-    const client = this.clients.get(account);
-    const att = await client.api(`/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`).select("name,contentType").get();
-    const data = await client.api(`/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}/$value`).responseType(ResponseType.ARRAYBUFFER).get();
-    const outPath = pathJoin(tmpdir(), att.name);
-    writeFileSync(outPath, Buffer.from(data));
-    return {
-      name: att.name,
-      contentType: att.contentType,
-      path: outPath
-    };
-  }
-  // Shared helper — creates a draft from a reference message (forward or
-  // reply), prepends our composed body before the existing content, and
-  // attaches inline images. Returns the draft message ID.
-  async buildDraftFromReference(client, createEndpoint, createPayload, converted) {
-    const draft = await client.api(createEndpoint).post(createPayload);
-    const draftMsg = await client.api(`/me/messages/${draft.id}`).select("body").get();
-    const draftBody = draftMsg.body?.content ?? "";
-    const draftContentType = draftMsg.body?.contentType ?? "HTML";
-    const spacer = '<div style="line-height:12px"><br></div>';
-    const prepend = converted.body + spacer;
-    const finalBody = draftBody.includes("<body") ? draftBody.replace(/(<body[^>]*>)/i, `$1${prepend}`) : prepend + draftBody;
-    await client.api(`/me/messages/${draft.id}`).patch({
-      body: { contentType: draftContentType, content: finalBody }
-    });
-    for (const att of converted.attachments) {
-      await client.api(`/me/messages/${draft.id}/attachments`).post(att);
-    }
-    return draft.id;
-  }
-  // Shared backend for sendEmail and saveDraft — handles forward, reply, and
-  // new-message paths. The `mode` controls whether the message is sent
-  // immediately or saved as a draft.
-  async sendOrSave(account, msg, mode) {
-    const client = this.clients.get(account);
-    const converted = convertInlineImages(msg.body);
-    const toRecipients = msg.to.map(toRecipient);
-    const ccRecipients = (msg.cc ?? []).map(toRecipient);
-    const bccRecipients = (msg.bcc ?? []).map(toRecipient);
-    if (msg.forwardMessageId) {
-      const draftId = await this.buildDraftFromReference(
-        client,
-        `/me/messages/${encodeURIComponent(msg.forwardMessageId)}/createForward`,
-        { message: { toRecipients, ccRecipients, bccRecipients }, comment: "" },
-        converted
-      );
-      if (mode === "send") {
-        await client.api(`/me/messages/${draftId}/send`).post({});
-      }
-      return { id: draftId };
-    }
-    if (msg.inReplyTo) {
-      const createEndpoint = msg.replyAll ? `/me/messages/${encodeURIComponent(msg.inReplyTo)}/createReplyAll` : `/me/messages/${encodeURIComponent(msg.inReplyTo)}/createReply`;
-      const draftId = await this.buildDraftFromReference(
-        client,
-        createEndpoint,
-        {},
-        converted
-      );
-      if (mode === "send") {
-        await client.api(`/me/messages/${draftId}/send`).post({});
-      }
-      return { id: draftId };
-    }
-    const messagePayload = {
-      subject: msg.subject,
-      body: {
-        contentType: msg.isHtml ? "HTML" : "Text",
-        content: converted.body
-      },
-      toRecipients,
-      ccRecipients,
-      bccRecipients
-    };
-    if (converted.attachments.length > 0) {
-      messagePayload.attachments = converted.attachments;
-    }
-    if (mode === "send") {
-      await client.api("/me/sendMail").post({
-        message: messagePayload,
-        saveToSentItems: true
-      });
-      return { id: "" };
-    }
-    const draft = await client.api("/me/messages").post(messagePayload);
-    return { id: draft.id };
+    return readAttachment(this.clients.get(account), account, messageId, attachmentId);
   }
   async sendEmail(account, msg) {
-    return this.sendOrSave(account, msg, "send");
+    return sendOrSave(this.clients.get(account), account, msg, "send");
   }
   async saveDraft(account, msg) {
-    return this.sendOrSave(account, msg, "draft");
+    return sendOrSave(this.clients.get(account), account, msg, "draft");
   }
   async updateDraft(account, id, update) {
-    const client = this.clients.get(account);
-    const payload = {};
-    if (update.subject !== void 0) {
-      payload.subject = update.subject;
-    }
-    if (update.to !== void 0) {
-      payload.toRecipients = update.to.map(toRecipient);
-    }
-    if (update.cc !== void 0) {
-      payload.ccRecipients = update.cc.map(toRecipient);
-    }
-    if (update.bcc !== void 0) {
-      payload.bccRecipients = update.bcc.map(toRecipient);
-    }
-    if (update.body !== void 0) {
-      const converted = convertInlineImages(update.body);
-      payload.body = {
-        contentType: update.isHtml ? "HTML" : "Text",
-        content: converted.body
-      };
-      if (converted.attachments.length > 0) {
-        payload.attachments = converted.attachments;
-      }
-    }
-    await client.api(`/me/messages/${encodeURIComponent(id)}`).patch(payload);
-    return { id };
+    return updateDraft(this.clients.get(account), account, id, update);
   }
   async moveEmail(account, id, destinationId) {
-    const client = this.clients.get(account);
-    await client.api(`/me/messages/${encodeURIComponent(id)}/move`).post({ destinationId });
+    return moveEmail(this.clients.get(account), account, id, destinationId);
   }
   async sendDraft(account, id) {
-    const client = this.clients.get(account);
-    await client.api(`/me/messages/${encodeURIComponent(id)}/send`).post({});
-    return { id };
+    return sendDraft(this.clients.get(account), account, id);
   }
   async addAttachmentToDraft(account, draftId, name, contentBytes, contentType) {
-    const client = this.clients.get(account);
-    const att = await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments`).post({
-      "@odata.type": "#microsoft.graph.fileAttachment",
+    return addAttachmentToDraft(
+      this.clients.get(account),
+      account,
+      draftId,
       name,
-      contentType: contentType ?? "application/octet-stream",
-      contentBytes
-    });
-    return {
-      id: draftId,
-      attachment: { id: att.id, name: att.name, contentType: att.contentType }
-    };
+      contentBytes,
+      contentType
+    );
+  }
+  async removeAttachmentFromDraft(account, draftId, attachmentId) {
+    return removeAttachmentFromDraft(this.clients.get(account), account, draftId, attachmentId);
   }
   async markRead(account, id, isRead) {
-    const client = this.clients.get(account);
-    await client.api(`/me/messages/${encodeURIComponent(id)}`).patch({ isRead });
+    return markRead(this.clients.get(account), account, id, isRead);
   }
+  // ---------- folder ops (delegated) ----------
   async listFolders(account, opts) {
-    const client = this.clients.get(account);
-    const endpoint = opts.parentFolderId ? `/me/mailFolders/${encodeURIComponent(opts.parentFolderId)}/childFolders` : "/me/mailFolders";
-    const res = await client.api(endpoint).select([
-      "id",
-      "displayName",
-      "parentFolderId",
-      "childFolderCount",
-      "totalItemCount",
-      "unreadItemCount"
-    ].join(",")).get();
-    return (res.value ?? []).map(mapFolder);
+    return listFolders(this.clients.get(account), account, opts);
   }
   async createFolder(account, input) {
-    const client = this.clients.get(account);
-    const parentId = input.parentFolderId ?? "msgfolderroot";
-    const created = await client.api(`/me/mailFolders/${encodeURIComponent(parentId)}/childFolders`).post({ displayName: input.displayName });
-    return mapFolder(created);
+    return createFolder(this.clients.get(account), account, input);
   }
   async renameFolder(account, folderId, newName) {
-    const client = this.clients.get(account);
-    const updated = await client.api(`/me/mailFolders/${encodeURIComponent(folderId)}`).patch({ displayName: newName });
-    return mapFolder(updated);
+    return renameFolder(this.clients.get(account), account, folderId, newName);
   }
   async deleteFolder(account, folderId) {
-    const client = this.clients.get(account);
-    await client.api(`/me/mailFolders/${encodeURIComponent(folderId)}`).delete();
+    return deleteFolder(this.clients.get(account), account, folderId);
   }
 };
-function mapFolder(f) {
-  return {
-    id: f.id,
-    displayName: f.displayName,
-    parentFolderId: f.parentFolderId,
-    childFolderCount: f.childFolderCount,
-    totalItemCount: f.totalItemCount,
-    unreadItemCount: f.unreadItemCount
-  };
-}
-function mapRecipient(r) {
-  return {
-    name: r.emailAddress?.name,
-    address: r.emailAddress?.address ?? ""
-  };
-}
-function mapSummary(m, folder) {
-  return {
-    id: m.id,
-    subject: m.subject ?? "",
-    from: m.from ? mapRecipient(m.from) : void 0,
-    to: (m.toRecipients ?? []).map(mapRecipient),
-    receivedAt: m.receivedDateTime,
-    preview: m.bodyPreview,
-    isRead: m.isRead,
-    hasAttachments: m.hasAttachments,
-    folder
-  };
-}
-function toRecipient(a) {
-  return { emailAddress: { name: a.name, address: a.address } };
-}
-function clampLimit(v, dflt, max) {
-  if (!v || v <= 0) return dflt;
-  return Math.min(v, max);
-}
 
 // src/providers/imap/client.ts
 import { ImapFlow } from "imapflow";
@@ -1000,7 +1053,7 @@ function mapMailboxToListEntry(m) {
 }
 
 // src/providers/imap/read-ops.ts
-async function listEmails(clients, account, opts) {
+async function listEmails2(clients, account, opts) {
   const client = clients.get(account);
   const folder = resolveFolder(opts.folder ?? "INBOX");
   const limit = clampLimit2(opts.limit, 25, 100);
@@ -1034,7 +1087,7 @@ async function listEmails(clients, account, opts) {
     return { items, hasMore };
   });
 }
-async function searchEmails(clients, account, query, opts) {
+async function searchEmails2(clients, account, query, opts) {
   const client = clients.get(account);
   const limit = clampLimit2(opts.limit, 25, 100);
   return client.withMailbox("INBOX", async (imap) => {
@@ -1057,7 +1110,7 @@ async function searchEmails(clients, account, query, opts) {
     );
   });
 }
-async function readEmail(clients, account, id) {
+async function readEmail2(clients, account, id) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
   return client.withMailbox(folder, async (imap) => {
@@ -1112,7 +1165,7 @@ async function readEmail(clients, account, id) {
     };
   });
 }
-async function readAttachment(clients, account, messageId, attachmentId) {
+async function readAttachment2(clients, account, messageId, attachmentId) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(messageId);
   return client.withMailbox(folder, async (imap) => {
@@ -1146,7 +1199,7 @@ async function readAttachment(clients, account, messageId, attachmentId) {
     };
   });
 }
-async function listFolders(clients, account, opts) {
+async function listFolders2(clients, account, opts) {
   const client = clients.get(account);
   const imap = await client.getImap();
   const mailboxes = await imap.list({
@@ -1170,9 +1223,7 @@ async function listFolders(clients, account, opts) {
   return results;
 }
 
-// src/providers/imap/write-ops.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import MailComposer from "nodemailer/lib/mail-composer/index.js";
+// src/providers/imap/account-ops.ts
 async function addAccount(clients, store, input) {
   const cfg = input.config ?? {};
   const host = String(cfg.host ?? "");
@@ -1231,6 +1282,65 @@ function completeAddAccount() {
     error: "IMAP accounts are set up synchronously \u2014 no polling needed. Call add_account with IMAP config to create the account directly."
   };
 }
+
+// src/providers/imap/write-ops.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import MailComposer from "nodemailer/lib/mail-composer/index.js";
+
+// src/providers/imap/mime-utils.ts
+function findAttachmentInMime(structure, attachmentId) {
+  if (!structure) return null;
+  if (Array.isArray(structure)) {
+    for (const part of structure) {
+      const result = findAttachmentInMime(part, attachmentId);
+      if (result) return result;
+    }
+    return null;
+  }
+  if (structure.id === attachmentId || structure.partId === attachmentId) {
+    return {
+      filename: structure.disposition?.filename || structure.filename || "attachment",
+      contentType: `${structure.type}/${structure.subtype}`
+    };
+  }
+  if (structure.parts) {
+    return findAttachmentInMime(structure.parts, attachmentId);
+  }
+  return null;
+}
+function removeMimePart(source, targetFilename, targetContentType) {
+  const lines = source.split("\r\n");
+  const result = [];
+  let skip = false;
+  let inTargetPart = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lowerLine = line.toLowerCase();
+    if (line.startsWith("--")) {
+      if (inTargetPart) {
+        skip = false;
+        inTargetPart = false;
+      }
+      result.push(line);
+      continue;
+    }
+    if (lowerLine.includes("content-disposition:") && lowerLine.includes(`filename="${targetFilename.toLowerCase()}"`)) {
+      inTargetPart = true;
+      skip = true;
+      continue;
+    }
+    if (inTargetPart && lowerLine.includes("content-type:") && lowerLine.includes(targetContentType.toLowerCase())) {
+      skip = true;
+      continue;
+    }
+    if (!skip) {
+      result.push(line);
+    }
+  }
+  return result.join("\r\n");
+}
+
+// src/providers/imap/write-ops.ts
 async function sendEmail(clients, account, msg) {
   const client = clients.get(account);
   const transporter = client.getTransporter();
@@ -1301,7 +1411,7 @@ async function saveDraft(clients, account, msg) {
     return { id: encodeId("Drafts", result.uid) };
   });
 }
-async function updateDraft(clients, account, id, update) {
+async function updateDraft2(clients, account, id, update) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
   return client.withMailbox(folder, async (imap) => {
@@ -1338,7 +1448,7 @@ async function updateDraft(clients, account, id, update) {
     return { id: encodeId(folder, result.uid) };
   });
 }
-async function moveEmail(clients, account, id, destinationId) {
+async function moveEmail2(clients, account, id, destinationId) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
   const dest = resolveFolder(destinationId);
@@ -1346,7 +1456,7 @@ async function moveEmail(clients, account, id, destinationId) {
     await imap.messageMove(uid, dest, { uid: true });
   });
 }
-async function sendDraft(clients, account, id) {
+async function sendDraft2(clients, account, id) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
   return client.withMailbox(folder, async (imap) => {
@@ -1368,7 +1478,7 @@ async function sendDraft(clients, account, id) {
     return { id: info.messageId };
   });
 }
-async function addAttachmentToDraft(clients, account, draftId, name, contentBytes, contentType) {
+async function addAttachmentToDraft2(clients, account, draftId, name, contentBytes, contentType) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(draftId);
   return client.withMailbox(folder, async (imap) => {
@@ -1409,7 +1519,29 @@ async function addAttachmentToDraft(clients, account, draftId, name, contentByte
     };
   });
 }
-async function markRead(clients, account, id, isRead) {
+async function removeAttachmentFromDraft2(clients, account, draftId, attachmentId) {
+  const client = clients.get(account);
+  const { folder, uid } = decodeId(draftId);
+  return client.withMailbox(folder, async (imap) => {
+    const existing = await imap.fetchOne(
+      uid,
+      { source: true, structure: true },
+      { uid: true }
+    );
+    if (!existing?.source) {
+      throw new Error(`draft not found: ${draftId}`);
+    }
+    const sourceStr = typeof existing.source === "string" ? existing.source : Buffer.from(existing.source).toString("utf-8");
+    const targetInfo = findAttachmentInMime(existing.structure, attachmentId);
+    if (!targetInfo) {
+      throw new Error(`attachment not found: ${attachmentId}`);
+    }
+    const modifiedSource = removeMimePart(sourceStr, targetInfo.filename, targetInfo.contentType);
+    await imap.messageDelete(uid, { uid: true });
+    await imap.append(folder, modifiedSource, ["\\Draft"]);
+  });
+}
+async function markRead2(clients, account, id, isRead) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
   return client.withMailbox(folder, async (imap) => {
@@ -1420,7 +1552,46 @@ async function markRead(clients, account, id, isRead) {
     }
   });
 }
-async function createFolder(clients, account, input) {
+async function buildRawMessage(account, msg, messageId) {
+  const mailOptions = {
+    from: `${account.displayName ?? ""} <${account.email}>`,
+    to: msg.to.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", "),
+    subject: msg.subject,
+    attachDataUrls: true
+  };
+  if (msg.isHtml) {
+    mailOptions.html = msg.body;
+  } else {
+    mailOptions.text = msg.body;
+  }
+  if (msg.cc && msg.cc.length > 0) {
+    mailOptions.cc = msg.cc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ");
+  }
+  if (msg.bcc && msg.bcc.length > 0) {
+    mailOptions.bcc = msg.bcc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ");
+  }
+  if (msg.attachments && msg.attachments.length > 0) {
+    const fileAttachments = msg.attachments.map((att) => ({
+      filename: att.name,
+      content: Buffer.from(att.contentBytes, "base64"),
+      contentType: att.contentType
+    }));
+    mailOptions.attachments = fileAttachments;
+  }
+  if (messageId) {
+    mailOptions.messageId = messageId;
+  }
+  return new Promise((resolve, reject) => {
+    const mc = new MailComposer(mailOptions);
+    mc.compile().build((err, buf) => {
+      if (err) reject(err);
+      else resolve(buf.toString("utf-8"));
+    });
+  });
+}
+
+// src/providers/imap/folders.ts
+async function createFolder2(clients, account, input) {
   const client = clients.get(account);
   const imap = await client.getImap();
   const path3 = input.parentFolderId ? `${input.parentFolderId}/${input.displayName}` : input.displayName;
@@ -1434,7 +1605,7 @@ async function createFolder(clients, account, input) {
     unreadItemCount: 0
   };
 }
-async function renameFolder(clients, account, folderId, newName) {
+async function renameFolder2(clients, account, folderId, newName) {
   const client = clients.get(account);
   const imap = await client.getImap();
   const lastSep = folderId.lastIndexOf("/");
@@ -1449,40 +1620,11 @@ async function renameFolder(clients, account, folderId, newName) {
     unreadItemCount: 0
   };
 }
-async function deleteFolder(clients, account, folderId) {
+async function deleteFolder2(clients, account, folderId) {
   const client = clients.get(account);
   const imap = await client.getImap();
   await imap.mailboxDelete(folderId);
 }
-async function buildRawMessage(account, msg, messageId) {
-  const mailOptions = {
-    from: `${account.displayName ?? ""} <${account.email}>`,
-    to: msg.to.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", "),
-    subject: msg.subject,
-    attachDataUrls: true
-  };
-  if (msg.isHtml) {
-    mailOptions.html = msg.body;
-  } else {
-    mailOptions.text = msg.body;
-  }
-  if (msg.cc && msg.cc.length > 0) {
-    mailOptions.cc = msg.cc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ");
-  }
-  if (msg.bcc && msg.bcc.length > 0) {
-    mailOptions.bcc = msg.bcc.map((a) => a.name ? `"${a.name}" <${a.address}>` : a.address).join(", ");
-  }
-  if (messageId) {
-    mailOptions.messageId = messageId;
-  }
-  return new Promise((resolve, reject) => {
-    const mc = new MailComposer(mailOptions);
-    mc.compile().build((err, buf) => {
-      if (err) reject(err);
-      else resolve(buf.toString("utf-8"));
-    });
-  });
-}
 
 // src/providers/imap/index.ts
 var ImapProvider = class {
@@ -1502,16 +1644,16 @@ var ImapProvider = class {
   }
   // ---------- browse ----------
   async listEmails(account, opts) {
-    return listEmails(this.clients, account, opts);
+    return listEmails2(this.clients, account, opts);
   }
   async searchEmails(account, query, opts) {
-    return searchEmails(this.clients, account, query, opts);
+    return searchEmails2(this.clients, account, query, opts);
   }
   async readEmail(account, id) {
-    return readEmail(this.clients, account, id);
+    return readEmail2(this.clients, account, id);
   }
   async readAttachment(account, messageId, attachmentId) {
-    return readAttachment(this.clients, account, messageId, attachmentId);
+    return readAttachment2(this.clients, account, messageId, attachmentId);
   }
   // ---------- compose ----------
   async sendEmail(account, msg) {
@@ -1521,33 +1663,36 @@ var ImapProvider = class {
     return saveDraft(this.clients, account, msg);
   }
   async updateDraft(account, id, update) {
-    return updateDraft(this.clients, account, id, update);
+    return updateDraft2(this.clients, account, id, update);
   }
   async moveEmail(account, id, destinationId) {
-    return moveEmail(this.clients, account, id, destinationId);
+    return moveEmail2(this.clients, account, id, destinationId);
   }
   async sendDraft(account, id) {
-    return sendDraft(this.clients, account, id);
+    return sendDraft2(this.clients, account, id);
   }
   async addAttachmentToDraft(account, draftId, name, contentBytes, contentType) {
-    return addAttachmentToDraft(this.clients, account, draftId, name, contentBytes, contentType);
+    return addAttachmentToDraft2(this.clients, account, draftId, name, contentBytes, contentType);
+  }
+  async removeAttachmentFromDraft(account, draftId, attachmentId) {
+    return removeAttachmentFromDraft2(this.clients, account, draftId, attachmentId);
   }
   // ---------- organize ----------
   async markRead(account, id, isRead) {
-    return markRead(this.clients, account, id, isRead);
+    return markRead2(this.clients, account, id, isRead);
   }
   // ---------- folders ----------
   async listFolders(account, opts) {
-    return listFolders(this.clients, account, opts);
+    return listFolders2(this.clients, account, opts);
   }
   async createFolder(account, input) {
-    return createFolder(this.clients, account, input);
+    return createFolder2(this.clients, account, input);
   }
   async renameFolder(account, folderId, newName) {
-    return renameFolder(this.clients, account, folderId, newName);
+    return renameFolder2(this.clients, account, folderId, newName);
   }
   async deleteFolder(account, folderId) {
-    return deleteFolder(this.clients, account, folderId);
+    return deleteFolder2(this.clients, account, folderId);
   }
 };
 
@@ -1954,6 +2099,17 @@ async function buildRawMessage2(account, msg, messageId) {
       cid: img.cid
     }));
   }
+  if (msg.attachments && msg.attachments.length > 0) {
+    const fileAttachments = msg.attachments.map((att) => ({
+      filename: att.name,
+      content: Buffer.from(att.contentBytes, "base64"),
+      contentType: att.contentType
+    }));
+    mailOptions.attachments = [
+      ...mailOptions.attachments || [],
+      ...fileAttachments
+    ];
+  }
   if (messageId) {
     mailOptions.messageId = messageId;
   }
@@ -1968,7 +2124,7 @@ async function buildRawMessage2(account, msg, messageId) {
 }
 
 // src/providers/gmail/read-ops.ts
-async function listEmails2(clients, account, opts) {
+async function listEmails3(clients, account, opts) {
   const { gmail } = clients.get(account);
   const limit = clampLimit3(opts.limit, 25, 100);
   const label = resolveLabel(opts.folder ?? "inbox");
@@ -2009,7 +2165,7 @@ async function listEmails2(clients, account, opts) {
   });
   return { items, hasMore };
 }
-async function searchEmails2(clients, account, query, opts) {
+async function searchEmails3(clients, account, query, opts) {
   const { gmail } = clients.get(account);
   const limit = clampLimit3(opts.limit, 25, 100);
   const res = await gmail.users.messages.list({
@@ -2035,7 +2191,7 @@ async function searchEmails2(clients, account, query, opts) {
   });
   return items;
 }
-async function readEmail2(clients, account, id) {
+async function readEmail3(clients, account, id) {
   const { gmail } = clients.get(account);
   const res = await gmail.users.messages.get({
     userId: "me",
@@ -2060,7 +2216,7 @@ async function readEmail2(clients, account, id) {
     hasAttachments: attachments.length > 0
   };
 }
-async function readAttachment2(clients, account, messageId, attachmentId) {
+async function readAttachment3(clients, account, messageId, attachmentId) {
   const { gmail } = clients.get(account);
   const msgRes = await gmail.users.messages.get({
     userId: "me",
@@ -2086,7 +2242,7 @@ async function readAttachment2(clients, account, messageId, attachmentId) {
   writeFileSync2(outPath, buf);
   return { name, contentType, path: outPath };
 }
-async function listFolders2(clients, account, _opts) {
+async function listFolders3(clients, account, _opts) {
   const { gmail } = clients.get(account);
   const res = await gmail.users.labels.list({ userId: "me" });
   const labels = res.data.labels ?? [];
@@ -2166,7 +2322,7 @@ async function saveDraft2(clients, account, msg) {
   });
   return { id: draftRes.data.message?.id ?? draftRes.data.id ?? "" };
 }
-async function updateDraft2(clients, account, id, update) {
+async function updateDraft3(clients, account, id, update) {
   const { gmail } = clients.get(account);
   const draftRes = await gmail.users.drafts.get({
     userId: "me",
@@ -2191,6 +2347,7 @@ async function updateDraft2(clients, account, id, update) {
     subject: update.subject ?? origSubject,
     body: update.body ?? "",
     isHtml: update.isHtml,
+    inReplyTo: false,
     cc: existingCc.length > 0 ? existingCc : void 0,
     bcc: existingBcc.length > 0 ? existingBcc : void 0
   });
@@ -2206,7 +2363,7 @@ async function updateDraft2(clients, account, id, update) {
   });
   return { id: updated.data.message?.id ?? updated.data.id ?? id };
 }
-async function moveEmail2(clients, account, id, destinationId) {
+async function moveEmail3(clients, account, id, destinationId) {
   const { gmail } = clients.get(account);
   const { addLabelIds, removeLabelIds } = resolveLabelsForMove(destinationId);
   await gmail.users.messages.modify({
@@ -2215,7 +2372,7 @@ async function moveEmail2(clients, account, id, destinationId) {
     requestBody: { addLabelIds, removeLabelIds }
   });
 }
-async function sendDraft2(clients, account, id) {
+async function sendDraft3(clients, account, id) {
   const { gmail } = clients.get(account);
   const res = await gmail.users.drafts.send({
     userId: "me",
@@ -2223,7 +2380,7 @@ async function sendDraft2(clients, account, id) {
   });
   return { id: res.data.id ?? id };
 }
-async function addAttachmentToDraft2(clients, account, draftId, name, contentBytes, contentType) {
+async function addAttachmentToDraft3(clients, account, draftId, name, contentBytes, contentType) {
   const { gmail } = clients.get(account);
   const draftRes = await gmail.users.drafts.get({
     userId: "me",
@@ -2273,7 +2430,86 @@ async function addAttachmentToDraft2(clients, account, draftId, name, contentByt
     }
   };
 }
-async function markRead2(clients, account, id, isRead) {
+async function removeAttachmentFromDraft3(clients, account, draftId, attachmentId) {
+  const { gmail } = clients.get(account);
+  const fullDraft = await gmail.users.drafts.get({
+    userId: "me",
+    id: draftId,
+    format: "full"
+  });
+  const message = fullDraft.data.message;
+  if (!message?.payload) {
+    throw new Error(`draft not found: ${draftId}`);
+  }
+  let targetFilename;
+  let targetMimeType;
+  function findAttachment(parts) {
+    if (!parts) return false;
+    for (const part of parts) {
+      if (part.body?.attachmentId === attachmentId) {
+        targetFilename = part.filename ?? void 0;
+        targetMimeType = part.mimeType ?? void 0;
+        return true;
+      }
+      if (part.parts && findAttachment(part.parts)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (!findAttachment(message.payload.parts)) {
+    throw new Error(`attachment not found: ${attachmentId}`);
+  }
+  const rawDraft = await gmail.users.drafts.get({
+    userId: "me",
+    id: draftId,
+    format: "raw"
+  });
+  const rawStr = Buffer2.from(
+    rawDraft.data.message.raw.replace(/-/g, "+").replace(/_/g, "/"),
+    "base64"
+  ).toString("utf-8");
+  const newRawStr = removeMimeAttachment(rawStr, targetFilename, targetMimeType);
+  await gmail.users.drafts.update({
+    userId: "me",
+    id: draftId,
+    requestBody: {
+      message: {
+        raw: base64urlEncode(Buffer2.from(newRawStr, "utf-8")),
+        threadId: message.threadId ?? void 0
+      }
+    }
+  });
+}
+function removeMimeAttachment(rawMime, targetFilename, targetMimeType) {
+  const boundaryMatch = rawMime.match(/boundary="?([^";]+)"?/i);
+  if (!boundaryMatch) {
+    return rawMime;
+  }
+  const boundary = boundaryMatch[1];
+  const delimiter = `--${boundary}`;
+  const parts = rawMime.split(delimiter);
+  const filtered = parts.filter((part) => {
+    if (!part.trim() || part.trim() === "--") {
+      return true;
+    }
+    const contentDispMatch = targetFilename && part.match(new RegExp(`Content-Disposition:.*?filename="?${escapeRegex(targetFilename)}"?`, "i"));
+    const contentTypeMatch = targetMimeType && part.match(new RegExp(`Content-Type:s*${escapeRegex(targetMimeType)}`, "i"));
+    if (targetFilename && targetMimeType) {
+      return !(contentDispMatch && contentTypeMatch);
+    } else if (targetFilename) {
+      return !contentDispMatch;
+    } else if (targetMimeType) {
+      return !contentTypeMatch;
+    }
+    return true;
+  });
+  return filtered.join(delimiter);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function markRead3(clients, account, id, isRead) {
   const { gmail } = clients.get(account);
   await gmail.users.messages.modify({
     userId: "me",
@@ -2284,7 +2520,7 @@ async function markRead2(clients, account, id, isRead) {
     }
   });
 }
-async function createFolder2(clients, account, input) {
+async function createFolder3(clients, account, input) {
   const { gmail } = clients.get(account);
   const created = await gmail.users.labels.create({
     userId: "me",
@@ -2296,7 +2532,7 @@ async function createFolder2(clients, account, input) {
   });
   return mapFolder2(created.data);
 }
-async function renameFolder2(clients, account, folderId, newName) {
+async function renameFolder3(clients, account, folderId, newName) {
   const { gmail } = clients.get(account);
   const updated = await gmail.users.labels.patch({
     userId: "me",
@@ -2305,7 +2541,7 @@ async function renameFolder2(clients, account, folderId, newName) {
   });
   return mapFolder2(updated.data);
 }
-async function deleteFolder2(clients, account, folderId) {
+async function deleteFolder3(clients, account, folderId) {
   const { gmail } = clients.get(account);
   await gmail.users.labels.delete({
     userId: "me",
@@ -2402,16 +2638,16 @@ var GmailProvider = class {
   }
   // ── browse ──
   async listEmails(account, opts) {
-    return listEmails2(this.clients, account, opts);
+    return listEmails3(this.clients, account, opts);
   }
   async searchEmails(account, query, opts) {
-    return searchEmails2(this.clients, account, query, opts);
+    return searchEmails3(this.clients, account, query, opts);
   }
   async readEmail(account, id) {
-    return readEmail2(this.clients, account, id);
+    return readEmail3(this.clients, account, id);
   }
   async readAttachment(account, messageId, attachmentId) {
-    return readAttachment2(this.clients, account, messageId, attachmentId);
+    return readAttachment3(this.clients, account, messageId, attachmentId);
   }
   // ── compose ──
   async sendEmail(account, msg) {
@@ -2421,16 +2657,16 @@ var GmailProvider = class {
     return saveDraft2(this.clients, account, msg);
   }
   async updateDraft(account, id, update) {
-    return updateDraft2(this.clients, account, id, update);
+    return updateDraft3(this.clients, account, id, update);
   }
   async moveEmail(account, id, destinationId) {
-    return moveEmail2(this.clients, account, id, destinationId);
+    return moveEmail3(this.clients, account, id, destinationId);
   }
   async sendDraft(account, id) {
-    return sendDraft2(this.clients, account, id);
+    return sendDraft3(this.clients, account, id);
   }
   async addAttachmentToDraft(account, draftId, name, contentBytes, contentType) {
-    return addAttachmentToDraft2(
+    return addAttachmentToDraft3(
       this.clients,
       account,
       draftId,
@@ -2439,22 +2675,25 @@ var GmailProvider = class {
       contentType
     );
   }
+  async removeAttachmentFromDraft(account, draftId, attachmentId) {
+    return removeAttachmentFromDraft3(this.clients, account, draftId, attachmentId);
+  }
   // ── organize ──
   async markRead(account, id, isRead) {
-    return markRead2(this.clients, account, id, isRead);
+    return markRead3(this.clients, account, id, isRead);
   }
   // ── folders ──
   async listFolders(account, opts) {
-    return listFolders2(this.clients, account, opts);
+    return listFolders3(this.clients, account, opts);
   }
   async createFolder(account, input) {
-    return createFolder2(this.clients, account, input);
+    return createFolder3(this.clients, account, input);
   }
   async renameFolder(account, folderId, newName) {
-    return renameFolder2(this.clients, account, folderId, newName);
+    return renameFolder3(this.clients, account, folderId, newName);
   }
   async deleteFolder(account, folderId) {
-    return deleteFolder2(this.clients, account, folderId);
+    return deleteFolder3(this.clients, account, folderId);
   }
 };
 
@@ -2601,6 +2840,31 @@ function buildStyleAttr(style) {
   if (style.fontColor) parts.push(`color: ${style.fontColor}`);
   return parts.join("; ");
 }
+function findThreadBoundary(html) {
+  const markerIdx = html.indexOf(THREAD_MARKER);
+  if (markerIdx !== -1) {
+    const before = html.slice(0, markerIdx);
+    let answerEnd = before.lastIndexOf(
+      '<div style="line-height:12px"><br></div>'
+    );
+    if (answerEnd === -1) {
+      const re = /<div\s+style=["'][^"']*line-height\s*:\s*12px[^"']*["']\s*>\s*<br\s*\/?>\s*<\/div>/gi;
+      let m;
+      while ((m = re.exec(before)) !== null) answerEnd = m.index;
+    }
+    return { threadStart: markerIdx, answerEnd: Math.max(answerEnd, 0) };
+  }
+  const spacerRe = /<div\s+style=["'][^"']*line-height\s*:\s*12px[^"']*["']\s*>\s*<br\s*\/?>\s*<\/div>/i;
+  const spacerMatch = spacerRe.exec(html);
+  if (spacerMatch) {
+    return { threadStart: spacerMatch.index, answerEnd: spacerMatch.index };
+  }
+  for (const re of [/id=["']?Signature["']?/i, /<blockquote/i]) {
+    const idx = html.search(re);
+    if (idx !== -1) return { threadStart: idx, answerEnd: idx };
+  }
+  return null;
+}
 function shouldRegister(name, tools) {
   if (tools.enabledTools) {
     return tools.enabledTools.has(name);
@@ -3305,6 +3569,31 @@ import { readFileSync } from "fs";
 import { basename, extname } from "path";
 function registerComposeTools(server, ctx) {
   const { store, registry, tools } = ctx;
+  const MIME_TYPES = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".txt": "text/plain",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".zip": "application/zip",
+    ".gz": "application/gzip",
+    ".tar": "application/x-tar",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4"
+  };
   const sendEmailSchema = z6.object({
     account: z6.string().email(),
     to: z6.array(emailAddrSchema).min(1),
@@ -3318,14 +3607,24 @@ function registerComposeTools(server, ctx) {
     include_signature: z6.boolean().describe(
       "Whether to append the account's saved HTML signature to the email. If true, don't include a signature in the body param to avoid double signature. Returns an error if true but no signature is configured for this account."
     ),
-    inReplyTo: z6.string().optional().describe(
-      "Message ID to reply to. When set, sends as a threaded reply which includes the quoted thread history automatically."
+    inReplyTo: z6.union([z6.string(), z6.literal(false)]).describe(
+      "Message ID to reply to. When set, sends as a threaded reply which includes the quoted thread history automatically. Set to `false` for a new email (not a reply)."
     ),
     replyAll: z6.boolean().default(false).optional().describe(
       "When true and `inReplyTo` is set, reply to all recipients instead of just the sender."
     ),
     forwardMessageId: z6.string().optional().describe(
       "Message ID to forward. When set, sends as a forward of the specified message, preserving the original content. Mutually exclusive with `inReplyTo`."
+    ),
+    attachments: z6.array(
+      z6.object({
+        filePath: z6.string().min(1).describe("Absolute path to a local file"),
+        name: z6.string().optional().describe(
+          "Attachment filename. Defaults to the file's basename."
+        )
+      })
+    ).optional().describe(
+      "File attachments to include. The server reads the files from disk and base64-encodes them automatically."
     )
   });
   async function handleSendOrDraft(args, action, resultKey, toolName) {
@@ -3348,6 +3647,18 @@ function registerComposeTools(server, ctx) {
           "inReplyTo and forwardMessageId are mutually exclusive \u2014 use one or the other"
         );
       }
+      let processedAttachments = void 0;
+      if (args.attachments && args.attachments.length > 0) {
+        processedAttachments = args.attachments.map((att) => {
+          const fileData = readFileSync(att.filePath);
+          const ext = extname(att.filePath).toLowerCase();
+          return {
+            name: att.name ?? basename(att.filePath),
+            contentBytes: fileData.toString("base64"),
+            contentType: MIME_TYPES[ext] ?? "application/octet-stream"
+          };
+        });
+      }
       const res = await action(provider, account, {
         to: args.to,
         cc: args.cc,
@@ -3357,7 +3668,8 @@ function registerComposeTools(server, ctx) {
         isHtml: composed.isHtml,
         inReplyTo: args.inReplyTo,
         replyAll: args.replyAll,
-        forwardMessageId: args.forwardMessageId
+        forwardMessageId: args.forwardMessageId,
+        attachments: processedAttachments
       });
       const result = { [resultKey]: true, ...res };
       if (toolName === "draft_email" && res.id) {
@@ -3423,6 +3735,19 @@ function registerComposeTools(server, ctx) {
     ),
     include_signature: z6.boolean().optional().describe(
       "Whether to re-apply the account's saved HTML signature to the body. If true, don't include a signature in the body param. Only meaningful when `body` is also provided. Returns an error if true but no signature is configured for this account."
+    ),
+    new_attachments: z6.array(
+      z6.object({
+        filePath: z6.string().min(1).describe("Absolute path to a local file"),
+        name: z6.string().optional().describe(
+          "Attachment filename. Defaults to the file's basename."
+        )
+      })
+    ).optional().describe(
+      "New file attachments to add to the draft. The server reads the files from disk and base64-encodes them automatically."
+    ),
+    remove_attachments: z6.array(z6.string().min(1)).optional().describe(
+      "Attachment IDs to remove from the draft. Get attachment IDs from read_email."
     )
   });
   const editDraftOutputSchema = {
@@ -3461,13 +3786,12 @@ function registerComposeTools(server, ctx) {
             isHtmlPayload = composed.isHtml;
           }
           if (bodyPayload !== void 0) {
-            const spacer = '<div style="line-height:12px"><br></div>';
             try {
               const existing = await provider.readEmail(account, a.id);
               const existingHtml = existing.bodyHtml ?? "";
-              const spacerIdx = existingHtml.indexOf(spacer);
-              if (spacerIdx !== -1) {
-                bodyPayload = bodyPayload + existingHtml.slice(spacerIdx);
+              const boundary = findThreadBoundary(existingHtml);
+              if (boundary !== null) {
+                bodyPayload = bodyPayload + existingHtml.slice(boundary.answerEnd);
               }
             } catch {
             }
@@ -3480,11 +3804,38 @@ function registerComposeTools(server, ctx) {
             body: bodyPayload,
             isHtml: isHtmlPayload
           });
+          const newAttachmentIds = [];
+          if (a.new_attachments && a.new_attachments.length > 0) {
+            for (const att of a.new_attachments) {
+              const fileData = readFileSync(att.filePath);
+              const ext = extname(att.filePath).toLowerCase();
+              const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+              const attRes = await provider.addAttachmentToDraft(
+                account,
+                res.id,
+                att.name ?? basename(att.filePath),
+                fileData.toString("base64"),
+                contentType
+              );
+              newAttachmentIds.push(attRes.attachment.id);
+            }
+          }
+          const removedIds = [];
+          if (a.remove_attachments && a.remove_attachments.length > 0) {
+            for (const attId of a.remove_attachments) {
+              await provider.removeAttachmentFromDraft(
+                account,
+                res.id,
+                attId
+              );
+              removedIds.push(attId);
+            }
+          }
           const draft = await provider.readEmail(account, res.id);
           const result = {
             edited: true,
             id: res.id,
-            draftHtml: draft.bodyHtml
+            draftHtml: draft.bodyHtml ?? ""
           };
           return ok(result, result);
         } catch (err) {
@@ -3520,99 +3871,6 @@ function registerComposeTools(server, ctx) {
       }
     );
   }
-  const MIME_TYPES = {
-    ".pdf": "application/pdf",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".svg": "image/svg+xml",
-    ".webp": "image/webp",
-    ".txt": "text/plain",
-    ".html": "text/html",
-    ".css": "text/css",
-    ".csv": "text/csv",
-    ".json": "application/json",
-    ".xml": "application/xml",
-    ".zip": "application/zip",
-    ".gz": "application/gzip",
-    ".tar": "application/x-tar",
-    ".doc": "application/msword",
-    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    ".xls": "application/vnd.ms-excel",
-    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    ".mp3": "audio/mpeg",
-    ".mp4": "video/mp4"
-  };
-  const addAttachmentOutputSchema = {
-    attached: z6.literal(true),
-    id: z6.string(),
-    attachment: z6.object({
-      id: z6.string(),
-      name: z6.string(),
-      contentType: z6.string().optional()
-    })
-  };
-  if (shouldRegister("add_attachment_to_draft", tools)) {
-    server.registerTool(
-      "add_attachment_to_draft",
-      {
-        description: "Add a file attachment to an existing draft email by ID. Provide exactly one of `contentBytes` (base64-encoded content) or `filePath` (absolute path to a local file). When using `filePath`, the file is read from disk and base64-encoded automatically, and `name` defaults to the file's basename if not provided. `contentType` is the MIME type (e.g. 'application/pdf'); when using `filePath` it is inferred from the extension if omitted. Disabled in --read-only mode.",
-        inputSchema: z6.object({
-          account: z6.string().email(),
-          id: z6.string().min(1).describe("Draft message ID"),
-          name: z6.string().min(1).optional().describe(
-            "Attachment filename (e.g. 'report.pdf'). Defaults to the file's basename when `filePath` is used."
-          ),
-          contentBytes: z6.string().min(1).optional().describe("Base64-encoded file content. Mutually exclusive with `filePath`."),
-          filePath: z6.string().min(1).optional().describe(
-            "Absolute path to a local file. The file is read and base64-encoded automatically. Mutually exclusive with `contentBytes`."
-          ),
-          contentType: z6.string().optional().describe("MIME type (e.g. 'application/pdf'). Inferred from `filePath` extension if omitted.")
-        }).refine(
-          (v) => Boolean(v.contentBytes) !== Boolean(v.filePath),
-          { message: "Provide exactly one of `contentBytes` or `filePath`." }
-        ),
-        outputSchema: addAttachmentOutputSchema
-      },
-      async (args) => {
-        try {
-          const { provider, account } = registry.resolveByEmail(args.account);
-          let contentBytes;
-          let name;
-          let contentType = args.contentType;
-          if (args.filePath) {
-            const fileData = readFileSync(args.filePath);
-            contentBytes = fileData.toString("base64");
-            name = args.name ?? basename(args.filePath);
-            if (!contentType) {
-              const ext = extname(args.filePath).toLowerCase();
-              contentType = MIME_TYPES[ext] ?? "application/octet-stream";
-            }
-          } else {
-            contentBytes = args.contentBytes;
-            name = args.name;
-          }
-          const res = await provider.addAttachmentToDraft(
-            account,
-            args.id,
-            name,
-            contentBytes,
-            contentType
-          );
-          const data = {
-            attached: true,
-            id: res.id,
-            attachment: res.attachment
-          };
-          return ok(data, data);
-        } catch (err) {
-          return fail(errMsg(err));
-        }
-      }
-    );
-  }
 }
 
 // src/tools/index.ts
@@ -3628,7 +3886,7 @@ function registerTools(server, opts) {
 // package.json
 var package_default = {
   name: "hypermail-mcp",
-  version: "0.7.3",
+  version: "0.7.5",
   description: "Unified email MCP server \u2014 operate any inbox (Outlook now, IMAP/Gmail later) by passing an email address.",
   type: "module",
   bin: {
@@ -3689,6 +3947,7 @@ var package_default = {
     "@types/isomorphic-fetch": "^0.0.39",
     "@types/node": "^22.10.2",
     "@types/nodemailer": "^8.0.0",
+    "@types/turndown": "^5.0.6",
     tsup: "^8.3.5",
     typescript: "^5.7.2",
     vitest: "^2.1.8"
@@ -3735,6 +3994,76 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/watcher/script.ts
+import { spawn } from "child_process";
+async function runScript(email, config) {
+  if (!config.script) return false;
+  const { path: scriptPath, timeoutMs, retry } = config.script;
+  const maxAttempts = retry?.maxAttempts ?? 5;
+  const baseDelayMs = retry?.baseDelayMs ?? 1e3;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (attempt > 0) {
+      const delay = baseDelayMs * 2 ** (attempt - 1);
+      await sleep2(delay);
+    }
+    try {
+      const ok2 = await spawnWithTimeout(
+        scriptPath,
+        JSON.stringify(email),
+        timeoutMs
+      );
+      if (ok2) return true;
+      console.error(
+        `[hypermail-watch] script ${email.id} attempt ${attempt + 1}/${maxAttempts}: non-zero exit code`
+      );
+    } catch (err) {
+      console.error(
+        `[hypermail-watch] script ${email.id} attempt ${attempt + 1}/${maxAttempts}: ${String(err)}`
+      );
+    }
+  }
+  console.error(
+    `[hypermail-watch] script delivery failed after ${maxAttempts} retries for ${email.id}`
+  );
+  return false;
+}
+function spawnWithTimeout(scriptPath, stdinData, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn("node", [scriptPath], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      if (stderr) {
+        console.error(`[hypermail-watch] script timed out after ${timeoutMs}ms. stderr:
+${stderr}`);
+      }
+      resolve(false);
+    }, timeoutMs);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (stderr && code !== 0) {
+        console.error(`[hypermail-watch] script stderr:
+${stderr}`);
+      }
+      resolve(code === 0);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      console.error(`[hypermail-watch] script spawn error: ${err.message}`);
+      resolve(false);
+    });
+    child.stdin?.end(stdinData);
+  });
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/watcher/manager.ts
 var WatcherManager = class {
   constructor(store, registry, config) {
@@ -3805,78 +4134,20 @@ var WatcherManager = class {
   }
   async emit(full) {
     await postWebhook(full, this.config);
+    runScript(full, this.config).catch((err) => {
+      console.error(
+        `[hypermail-watch] script unhandled error for ${full.id}:`,
+        err
+      );
+    });
   }
 };
 
 // src/config.ts
-import { readFileSync as readFileSync2 } from "fs";
 import { z as z7 } from "zod";
-var httpConfigSchema = z7.object({
-  enabled: z7.boolean().default(false),
-  port: z7.number().int().min(1).max(65535).default(3e3),
-  host: z7.string().default("127.0.0.1")
-});
-var toolsConfigSchema = z7.object({
-  disabled: z7.array(z7.string()).optional(),
-  enabled: z7.array(z7.string()).optional()
-});
-var outlookProviderSchema = z7.object({
-  clientId: z7.string().optional(),
-  tenantId: z7.string().optional()
-});
-var gmailProviderSchema = z7.object({
-  clientId: z7.string().optional(),
-  clientSecret: z7.string().optional()
-});
-var providersConfigSchema = z7.object({
-  outlook: outlookProviderSchema.optional(),
-  gmail: gmailProviderSchema.optional()
-});
-var watchConfigSchema = z7.object({
-  enabled: z7.boolean().default(false),
-  pollIntervalSeconds: z7.number().int().min(10).max(3600).default(10),
-  webhook: z7.object({
-    url: z7.string(),
-    retry: z7.object({
-      maxAttempts: z7.number().int().min(1).max(10).default(5),
-      baseDelayMs: z7.number().int().min(100).default(1e3)
-    }).optional()
-  }).optional()
-});
-var rawConfigSchema = z7.object({
-  dataDir: z7.string().optional(),
-  http: httpConfigSchema.optional(),
-  tools: toolsConfigSchema.optional(),
-  providers: providersConfigSchema.optional(),
-  watch: watchConfigSchema.optional()
-});
-var KNOWN_TOOLS = [
-  "list_accounts",
-  "add_account",
-  "complete_add_account",
-  "get_account_settings",
-  "set_account_settings",
-  "remove_account",
-  "list_emails",
-  "search_emails",
-  "read_email",
-  "read_attachment",
-  "archive_email",
-  "trash_email",
-  "move_email",
-  "mark_read",
-  "mark_unread",
-  "list_folders",
-  "create_folder",
-  "delete_folder",
-  "rename_folder",
-  "send_email",
-  "draft_email",
-  "edit_draft",
-  "send_draft",
-  "add_attachment_to_draft",
-  "check_notifications"
-];
+
+// src/config/load.ts
+import { readFileSync as readFileSync2 } from "fs";
 var ENV_HTTP_ENABLED = "HYPERMAIL_HTTP_ENABLED";
 var ENV_HTTP_PORT = "HYPERMAIL_HTTP_PORT";
 var ENV_HTTP_HOST = "HYPERMAIL_HTTP_HOST";
@@ -3891,6 +4162,10 @@ var ENV_WATCH_POLL_INTERVAL = "HYPERMAIL_WATCH_POLL_INTERVAL";
 var ENV_WATCH_WEBHOOK_URL = "HYPERMAIL_WATCH_WEBHOOK_URL";
 var ENV_WATCH_WEBHOOK_RETRY_MAX_ATTEMPTS = "HYPERMAIL_WATCH_WEBHOOK_RETRY_MAX_ATTEMPTS";
 var ENV_WATCH_WEBHOOK_RETRY_BASE_DELAY = "HYPERMAIL_WATCH_WEBHOOK_RETRY_BASE_DELAY_MS";
+var ENV_WATCH_SCRIPT_PATH = "HYPERMAIL_WATCH_SCRIPT_PATH";
+var ENV_WATCH_SCRIPT_TIMEOUT_MS = "HYPERMAIL_WATCH_SCRIPT_TIMEOUT_MS";
+var ENV_WATCH_SCRIPT_RETRY_MAX_ATTEMPTS = "HYPERMAIL_WATCH_SCRIPT_RETRY_MAX_ATTEMPTS";
+var ENV_WATCH_SCRIPT_RETRY_BASE_DELAY = "HYPERMAIL_WATCH_SCRIPT_RETRY_BASE_DELAY_MS";
 var LEGACY_MS_CLIENT_ID = "MS_CLIENT_ID";
 var LEGACY_MS_TENANT_ID = "MS_TENANT_ID";
 var LEGACY_GOOGLE_CLIENT_ID = "GOOGLE_CLIENT_ID";
@@ -4007,10 +4282,26 @@ function loadConfig(configPath, cliOverrides = {}) {
         retry: { maxAttempts: retryMaxAttempts, baseDelayMs: retryBaseDelayMs }
       };
     }
+    const scriptPath = parsed.watch?.script?.path ?? process.env[ENV_WATCH_SCRIPT_PATH];
+    let script;
+    if (scriptPath) {
+      const scriptTimeoutMs = parsed.watch?.script?.timeoutMs ?? parseIntSafe(process.env[ENV_WATCH_SCRIPT_TIMEOUT_MS]) ?? 3e4;
+      const scriptRetryMaxAttempts = parsed.watch?.script?.retry?.maxAttempts ?? parseIntSafe(process.env[ENV_WATCH_SCRIPT_RETRY_MAX_ATTEMPTS]) ?? 5;
+      const scriptRetryBaseDelayMs = parsed.watch?.script?.retry?.baseDelayMs ?? parseIntSafe(process.env[ENV_WATCH_SCRIPT_RETRY_BASE_DELAY]) ?? 1e3;
+      script = {
+        path: scriptPath,
+        timeoutMs: scriptTimeoutMs,
+        retry: {
+          maxAttempts: scriptRetryMaxAttempts,
+          baseDelayMs: scriptRetryBaseDelayMs
+        }
+      };
+    }
     watch = {
       enabled: watchEnabledEnv ?? parsed.watch?.enabled ?? false,
       pollIntervalSeconds: parsed.watch?.pollIntervalSeconds ?? parseIntSafe(process.env[ENV_WATCH_POLL_INTERVAL]) ?? 10,
-      webhook
+      webhook,
+      script
     };
   }
   return {
@@ -4021,6 +4312,81 @@ function loadConfig(configPath, cliOverrides = {}) {
     watch
   };
 }
+
+// src/config.ts
+var httpConfigSchema = z7.object({
+  enabled: z7.boolean().default(false),
+  port: z7.number().int().min(1).max(65535).default(3e3),
+  host: z7.string().default("127.0.0.1")
+});
+var toolsConfigSchema = z7.object({
+  disabled: z7.array(z7.string()).optional(),
+  enabled: z7.array(z7.string()).optional()
+});
+var outlookProviderSchema = z7.object({
+  clientId: z7.string().optional(),
+  tenantId: z7.string().optional()
+});
+var gmailProviderSchema = z7.object({
+  clientId: z7.string().optional(),
+  clientSecret: z7.string().optional()
+});
+var providersConfigSchema = z7.object({
+  outlook: outlookProviderSchema.optional(),
+  gmail: gmailProviderSchema.optional()
+});
+var watchRetrySchema = z7.object({
+  maxAttempts: z7.number().int().min(1).max(10).default(5),
+  baseDelayMs: z7.number().int().min(100).default(1e3)
+});
+var watchWebhookSchema = z7.object({
+  url: z7.string(),
+  retry: watchRetrySchema.optional()
+});
+var watchScriptSchema = z7.object({
+  path: z7.string(),
+  timeoutMs: z7.number().int().min(1e3).default(3e4),
+  retry: watchRetrySchema.optional()
+});
+var watchConfigSchema = z7.object({
+  enabled: z7.boolean().default(false),
+  pollIntervalSeconds: z7.number().int().min(10).max(3600).default(10),
+  webhook: watchWebhookSchema.optional(),
+  script: watchScriptSchema.optional()
+});
+var rawConfigSchema = z7.object({
+  dataDir: z7.string().optional(),
+  http: httpConfigSchema.optional(),
+  tools: toolsConfigSchema.optional(),
+  providers: providersConfigSchema.optional(),
+  watch: watchConfigSchema.optional()
+});
+var KNOWN_TOOLS = [
+  "list_accounts",
+  "add_account",
+  "complete_add_account",
+  "get_account_settings",
+  "set_account_settings",
+  "remove_account",
+  "list_emails",
+  "search_emails",
+  "read_email",
+  "read_attachment",
+  "archive_email",
+  "trash_email",
+  "move_email",
+  "mark_read",
+  "mark_unread",
+  "list_folders",
+  "create_folder",
+  "delete_folder",
+  "rename_folder",
+  "send_email",
+  "draft_email",
+  "edit_draft",
+  "send_draft",
+  "check_notifications"
+];
 function resolveTools(config) {
   if (!config.tools) {
     return { enabledTools: null, disabledTools: null };