@agenticmail/enterprise 0.5.151 → 0.5.153

package/dist/chunk-VEPWCYAL.js

@@ -0,0 +1,1131 @@
+// src/agenticmail/providers/microsoft.ts
+var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+var MicrosoftEmailProvider = class {
+  provider = "microsoft";
+  identity = null;
+  get token() {
+    if (!this.identity) throw new Error("Not connected");
+    return this.identity.accessToken;
+  }
+  async refreshIfNeeded() {
+    if (this.identity?.refreshToken) {
+      this.identity.accessToken = await this.identity.refreshToken();
+    }
+  }
+  async graphFetch(path, opts) {
+    await this.refreshIfNeeded();
+    const res = await fetch(`${GRAPH_BASE}${path}`, {
+      ...opts,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        ...opts?.headers
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Graph API ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+  // ─── Connection ─────────────────────────────────────
+  async connect(identity) {
+    this.identity = identity;
+    await this.graphFetch("/me?$select=mail,displayName");
+  }
+  async disconnect() {
+    this.identity = null;
+  }
+  // ─── List / Read ────────────────────────────────────
+  async listMessages(folder, opts) {
+    const folderId = this.resolveFolderId(folder);
+    const top = opts?.limit || 20;
+    const skip = opts?.offset || 0;
+    const data = await this.graphFetch(
+      `/me/mailFolders/${folderId}/messages?$top=${top}&$skip=${skip}&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview&$orderby=receivedDateTime desc`
+    );
+    return (data.value || []).map((m) => this.toEnvelope(m));
+  }
+  async readMessage(uid) {
+    const data = await this.graphFetch(`/me/messages/${uid}?$select=id,subject,from,toRecipients,ccRecipients,bccRecipients,receivedDateTime,isRead,flag,hasAttachments,body,bodyPreview,replyTo,internetMessageId,internetMessageHeaders,conversationId`);
+    return this.toMessage(data);
+  }
+  async searchMessages(criteria) {
+    const filters = [];
+    if (criteria.from) filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+    if (criteria.subject) filters.push(`contains(subject, '${criteria.subject}')`);
+    if (criteria.since) filters.push(`receivedDateTime ge ${criteria.since}`);
+    if (criteria.before) filters.push(`receivedDateTime lt ${criteria.before}`);
+    if (criteria.seen !== void 0) filters.push(`isRead eq ${criteria.seen}`);
+    let path = "/me/messages?$top=50&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview&$orderby=receivedDateTime desc";
+    if (filters.length) path += "&$filter=" + encodeURIComponent(filters.join(" and "));
+    if (criteria.text) path = `/me/messages?$search="${encodeURIComponent(criteria.text)}"&$top=50&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview`;
+    const data = await this.graphFetch(path);
+    return (data.value || []).map((m) => this.toEnvelope(m));
+  }
+  async listFolders() {
+    const data = await this.graphFetch("/me/mailFolders?$select=id,displayName,unreadItemCount,totalItemCount");
+    return (data.value || []).map((f) => ({
+      name: f.displayName,
+      path: f.id,
+      unread: f.unreadItemCount || 0,
+      total: f.totalItemCount || 0
+    }));
+  }
+  async createFolder(name) {
+    await this.graphFetch("/me/mailFolders", {
+      method: "POST",
+      body: JSON.stringify({ displayName: name })
+    });
+  }
+  // ─── Send ───────────────────────────────────────────
+  async send(options) {
+    const message = this.buildGraphMessage(options);
+    await this.graphFetch("/me/sendMail", {
+      method: "POST",
+      body: JSON.stringify({ message, saveToSentItems: true })
+    });
+    return { messageId: `graph-${Date.now()}` };
+  }
+  async reply(uid, body, replyAll = false) {
+    const endpoint = replyAll ? "replyAll" : "reply";
+    await this.graphFetch(`/me/messages/${uid}/${endpoint}`, {
+      method: "POST",
+      body: JSON.stringify({ comment: body })
+    });
+    return { messageId: `graph-reply-${Date.now()}` };
+  }
+  async forward(uid, to, body) {
+    await this.graphFetch(`/me/messages/${uid}/forward`, {
+      method: "POST",
+      body: JSON.stringify({
+        comment: body || "",
+        toRecipients: [{ emailAddress: { address: to } }]
+      })
+    });
+    return { messageId: `graph-fwd-${Date.now()}` };
+  }
+  // ─── Organize ───────────────────────────────────────
+  async moveMessage(uid, toFolder) {
+    const folderId = this.resolveFolderId(toFolder);
+    await this.graphFetch(`/me/messages/${uid}/move`, {
+      method: "POST",
+      body: JSON.stringify({ destinationId: folderId })
+    });
+  }
+  async deleteMessage(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, { method: "DELETE" });
+  }
+  async markRead(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ isRead: true })
+    });
+  }
+  async markUnread(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ isRead: false })
+    });
+  }
+  async flagMessage(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ flag: { flagStatus: "flagged" } })
+    });
+  }
+  async unflagMessage(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ flag: { flagStatus: "notFlagged" } })
+    });
+  }
+  // ─── Batch ──────────────────────────────────────────
+  async batchMarkRead(uids) {
+    await Promise.all(uids.map((uid) => this.markRead(uid)));
+  }
+  async batchMarkUnread(uids) {
+    await Promise.all(uids.map((uid) => this.markUnread(uid)));
+  }
+  async batchMove(uids, toFolder) {
+    await Promise.all(uids.map((uid) => this.moveMessage(uid, toFolder)));
+  }
+  async batchDelete(uids) {
+    await Promise.all(uids.map((uid) => this.deleteMessage(uid)));
+  }
+  // ─── Helpers ────────────────────────────────────────
+  resolveFolderId(folder) {
+    const map = {
+      INBOX: "inbox",
+      inbox: "inbox",
+      Sent: "sentItems",
+      sent: "sentItems",
+      sentitems: "sentItems",
+      Drafts: "drafts",
+      drafts: "drafts",
+      Trash: "deletedItems",
+      trash: "deletedItems",
+      deleteditems: "deletedItems",
+      Junk: "junkemail",
+      junk: "junkemail",
+      spam: "junkemail",
+      Archive: "archive",
+      archive: "archive"
+    };
+    return map[folder] || folder;
+  }
+  buildGraphMessage(options) {
+    const msg = {
+      subject: options.subject,
+      body: { contentType: options.html ? "HTML" : "Text", content: options.html || options.body },
+      toRecipients: options.to.split(",").map((e) => ({ emailAddress: { address: e.trim() } }))
+    };
+    if (options.cc) msg.ccRecipients = options.cc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
+    if (options.bcc) msg.bccRecipients = options.bcc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
+    if (options.inReplyTo) msg.internetMessageHeaders = [{ name: "In-Reply-To", value: options.inReplyTo }];
+    return msg;
+  }
+  toEnvelope(m) {
+    return {
+      uid: m.id,
+      from: { name: m.from?.emailAddress?.name, email: m.from?.emailAddress?.address || "" },
+      to: (m.toRecipients || []).map((r) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || "" })),
+      subject: m.subject || "",
+      date: m.receivedDateTime || "",
+      read: !!m.isRead,
+      flagged: m.flag?.flagStatus === "flagged",
+      hasAttachments: !!m.hasAttachments,
+      preview: m.bodyPreview || ""
+    };
+  }
+  toMessage(m) {
+    return {
+      uid: m.id,
+      from: { name: m.from?.emailAddress?.name, email: m.from?.emailAddress?.address || "" },
+      to: (m.toRecipients || []).map((r) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || "" })),
+      cc: (m.ccRecipients || []).map((r) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || "" })),
+      subject: m.subject || "",
+      body: m.body?.contentType === "HTML" ? "" : m.body?.content || "",
+      html: m.body?.contentType === "HTML" ? m.body?.content : void 0,
+      date: m.receivedDateTime || "",
+      read: !!m.isRead,
+      flagged: m.flag?.flagStatus === "flagged",
+      folder: "inbox",
+      messageId: m.internetMessageId,
+      attachments: []
+    };
+  }
+};
+
+// src/agenticmail/providers/google.ts
+var GMAIL_BASE = "https://gmail.googleapis.com/gmail/v1";
+var GoogleEmailProvider = class {
+  provider = "google";
+  identity = null;
+  userId = "me";
+  get token() {
+    if (!this.identity) throw new Error("Not connected");
+    return this.identity.accessToken;
+  }
+  async refreshIfNeeded() {
+    if (this.identity?.refreshToken) {
+      this.identity.accessToken = await this.identity.refreshToken();
+    }
+  }
+  async gmailFetch(path, opts) {
+    await this.refreshIfNeeded();
+    const res = await fetch(`${GMAIL_BASE}/users/${this.userId}${path}`, {
+      ...opts,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        ...opts?.headers
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Gmail API ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+  // ─── Connection ─────────────────────────────────────
+  async connect(identity) {
+    this.identity = identity;
+    await this.gmailFetch("/profile");
+  }
+  async disconnect() {
+    this.identity = null;
+  }
+  // ─── List / Read ────────────────────────────────────
+  async listMessages(folder, opts) {
+    const labelId = this.resolveLabelId(folder);
+    const maxResults = opts?.limit || 20;
+    const q = labelId === "INBOX" ? "" : "";
+    const data = await this.gmailFetch(`/messages?labelIds=${labelId}&maxResults=${maxResults}${q ? "&q=" + encodeURIComponent(q) : ""}`);
+    if (!data.messages?.length) return [];
+    const envelopes = [];
+    let skipped = 0;
+    for (const msg of data.messages) {
+      try {
+        const detail = await this.gmailFetch(`/messages/${msg.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        envelopes.push(this.metadataToEnvelope(detail));
+      } catch (e) {
+        skipped++;
+        console.error(`[gmail] Failed to fetch metadata for ${msg.id}: ${e.message?.slice(0, 100)}`);
+      }
+    }
+    if (skipped > 0) console.warn(`[gmail] Skipped ${skipped}/${data.messages.length} messages due to errors`);
+    return envelopes;
+  }
+  async readMessage(uid) {
+    const data = await this.gmailFetch(`/messages/${uid}?format=full`);
+    return this.fullToMessage(data);
+  }
+  async searchMessages(criteria) {
+    const parts = [];
+    if (criteria.from) parts.push(`from:${criteria.from}`);
+    if (criteria.to) parts.push(`to:${criteria.to}`);
+    if (criteria.subject) parts.push(`subject:${criteria.subject}`);
+    if (criteria.text) parts.push(criteria.text);
+    if (criteria.since) parts.push(`after:${criteria.since.split("T")[0]}`);
+    if (criteria.before) parts.push(`before:${criteria.before.split("T")[0]}`);
+    if (criteria.seen === true) parts.push("is:read");
+    if (criteria.seen === false) parts.push("is:unread");
+    const q = parts.join(" ");
+    const data = await this.gmailFetch(`/messages?q=${encodeURIComponent(q)}&maxResults=50`);
+    if (!data.messages?.length) return [];
+    const envelopes = [];
+    for (const msg of data.messages.slice(0, 20)) {
+      try {
+        const detail = await this.gmailFetch(`/messages/${msg.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        envelopes.push(this.metadataToEnvelope(detail));
+      } catch {
+      }
+    }
+    return envelopes;
+  }
+  async listFolders() {
+    const data = await this.gmailFetch("/labels");
+    return (data.labels || []).map((l) => ({
+      name: l.name,
+      path: l.id,
+      unread: l.messagesUnread || 0,
+      total: l.messagesTotal || 0
+    }));
+  }
+  async createFolder(name) {
+    await this.gmailFetch("/labels", {
+      method: "POST",
+      body: JSON.stringify({ name, labelListVisibility: "labelShow", messageListVisibility: "show" })
+    });
+  }
+  // ─── Send ───────────────────────────────────────────
+  async send(options) {
+    const raw = this.buildRawEmail(options);
+    const sendBody = { raw };
+    if (options.threadId) sendBody.threadId = options.threadId;
+    const data = await this.gmailFetch("/messages/send", {
+      method: "POST",
+      body: JSON.stringify(sendBody)
+    });
+    return { messageId: data.id };
+  }
+  async reply(uid, body, replyAll = false) {
+    const originalData = await this.gmailFetch(`/messages/${uid}?format=full`);
+    const original = this.fullToMessage(originalData);
+    const threadId = originalData.threadId;
+    const to = replyAll ? [original.from.email, ...(original.to || []).map((t) => t.email), ...(original.cc || []).map((c) => c.email)].filter((e) => e !== this.identity?.email).join(", ") : original.from.email;
+    return this.send({
+      to,
+      subject: original.subject.startsWith("Re:") ? original.subject : `Re: ${original.subject}`,
+      body,
+      inReplyTo: original.messageId,
+      references: original.references ? [...original.references, original.messageId] : [original.messageId],
+      threadId
+    });
+  }
+  async forward(uid, to, body) {
+    const original = await this.readMessage(uid);
+    return this.send({
+      to,
+      subject: `Fwd: ${original.subject}`,
+      body: (body ? body + "\n\n" : "") + `---------- Forwarded message ----------
+From: ${original.from.email}
+Date: ${original.date}
+Subject: ${original.subject}
+
+${original.body}`
+    });
+  }
+  // ─── Organize ───────────────────────────────────────
+  async moveMessage(uid, toFolder, fromFolder) {
+    const addLabel = this.resolveLabelId(toFolder);
+    const removeLabel = fromFolder ? this.resolveLabelId(fromFolder) : "INBOX";
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ addLabelIds: [addLabel], removeLabelIds: [removeLabel] })
+    });
+  }
+  async deleteMessage(uid) {
+    await this.gmailFetch(`/messages/${uid}/trash`, { method: "POST" });
+  }
+  async markRead(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ removeLabelIds: ["UNREAD"] })
+    });
+  }
+  async markUnread(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ addLabelIds: ["UNREAD"] })
+    });
+  }
+  async flagMessage(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ addLabelIds: ["STARRED"] })
+    });
+  }
+  async unflagMessage(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ removeLabelIds: ["STARRED"] })
+    });
+  }
+  // ─── Batch ──────────────────────────────────────────
+  async batchMarkRead(uids) {
+    await this.gmailFetch("/messages/batchModify", {
+      method: "POST",
+      body: JSON.stringify({ ids: uids, removeLabelIds: ["UNREAD"] })
+    });
+  }
+  async batchMarkUnread(uids) {
+    await this.gmailFetch("/messages/batchModify", {
+      method: "POST",
+      body: JSON.stringify({ ids: uids, addLabelIds: ["UNREAD"] })
+    });
+  }
+  async batchMove(uids, toFolder, fromFolder) {
+    const addLabel = this.resolveLabelId(toFolder);
+    const removeLabel = fromFolder ? this.resolveLabelId(fromFolder) : "INBOX";
+    await this.gmailFetch("/messages/batchModify", {
+      method: "POST",
+      body: JSON.stringify({ ids: uids, addLabelIds: [addLabel], removeLabelIds: [removeLabel] })
+    });
+  }
+  async batchDelete(uids) {
+    await Promise.all(uids.map((uid) => this.deleteMessage(uid)));
+  }
+  // ─── Gmail Push Notifications ────────────────────────
+  /**
+   * Set up Gmail push notifications via Google Cloud Pub/Sub.
+   * Gmail will POST to your Pub/Sub topic when new emails arrive.
+   * Requires: Pub/Sub topic created, Gmail API granted publish permission.
+   * Returns: historyId and expiration (watch lasts ~7 days, must renew).
+   */
+  async watchInbox(topicName) {
+    const data = await this.gmailFetch("/watch", {
+      method: "POST",
+      body: JSON.stringify({
+        topicName,
+        labelIds: ["INBOX"],
+        labelFilterBehavior: "INCLUDE"
+      })
+    });
+    return { historyId: data.historyId, expiration: data.expiration };
+  }
+  /**
+   * Stop Gmail push notifications.
+   */
+  async stopWatch() {
+    await this.gmailFetch("/stop", { method: "POST" });
+  }
+  /**
+   * Get message history since a historyId (for processing push notification deltas).
+   */
+  async getHistory(startHistoryId) {
+    const data = await this.gmailFetch(`/history?startHistoryId=${startHistoryId}&historyTypes=messageAdded&labelId=INBOX`);
+    const messages = [];
+    for (const h of data.history || []) {
+      for (const added of h.messagesAdded || []) {
+        if (added.message?.id) messages.push({ id: added.message.id, threadId: added.message.threadId });
+      }
+    }
+    return { messages, historyId: data.historyId || startHistoryId };
+  }
+  // ─── Helpers ────────────────────────────────────────
+  resolveLabelId(folder) {
+    const map = {
+      INBOX: "INBOX",
+      inbox: "INBOX",
+      Sent: "SENT",
+      sent: "SENT",
+      Drafts: "DRAFT",
+      drafts: "DRAFT",
+      Trash: "TRASH",
+      trash: "TRASH",
+      Spam: "SPAM",
+      spam: "SPAM",
+      Junk: "SPAM",
+      junk: "SPAM",
+      Starred: "STARRED",
+      starred: "STARRED",
+      Important: "IMPORTANT",
+      important: "IMPORTANT"
+    };
+    return map[folder] || folder;
+  }
+  buildRawEmail(options) {
+    const fromAddr = this.identity?.email;
+    const fromName = this.identity?.name;
+    const lines = [
+      `MIME-Version: 1.0`,
+      fromAddr ? `From: ${fromName ? `"${fromName}" <${fromAddr}>` : fromAddr}` : "",
+      `To: ${options.to}`,
+      `Subject: ${options.subject}`,
+      `Content-Type: text/plain; charset=utf-8`,
+      `Content-Transfer-Encoding: 7bit`
+    ].filter(Boolean);
+    if (options.cc) lines.splice(3, 0, `Cc: ${options.cc}`);
+    if (options.inReplyTo) lines.push(`In-Reply-To: ${options.inReplyTo}`);
+    if (options.references?.length) lines.push(`References: ${options.references.join(" ")}`);
+    lines.push("", options.body);
+    const raw = lines.join("\r\n");
+    return Buffer.from(raw, "utf-8").toString("base64url");
+  }
+  getHeader(msg, name) {
+    const headers = msg.payload?.headers || [];
+    const h = headers.find((h2) => h2.name.toLowerCase() === name.toLowerCase());
+    return h?.value || "";
+  }
+  metadataToEnvelope(msg) {
+    const from = this.getHeader(msg, "From");
+    const fromMatch = from.match(/^(.*?)\s*<(.+?)>$/) || [null, "", from];
+    return {
+      uid: msg.id,
+      from: { name: fromMatch[1]?.replace(/"/g, "").trim() || void 0, email: fromMatch[2] || from },
+      to: [{ email: this.getHeader(msg, "To") }],
+      subject: this.getHeader(msg, "Subject"),
+      date: this.getHeader(msg, "Date"),
+      read: !(msg.labelIds || []).includes("UNREAD"),
+      flagged: (msg.labelIds || []).includes("STARRED"),
+      hasAttachments: false,
+      preview: msg.snippet || ""
+    };
+  }
+  fullToMessage(msg) {
+    const from = this.getHeader(msg, "From");
+    const fromMatch = from.match(/^(.*?)\s*<(.+?)>$/) || [null, "", from];
+    let body = "";
+    let html;
+    const extractBody = (payload) => {
+      if (payload.mimeType === "text/plain" && payload.body?.data) {
+        body = Buffer.from(payload.body.data, "base64url").toString("utf-8");
+      }
+      if (payload.mimeType === "text/html" && payload.body?.data) {
+        html = Buffer.from(payload.body.data, "base64url").toString("utf-8");
+      }
+      if (payload.parts) payload.parts.forEach(extractBody);
+    };
+    if (msg.payload) extractBody(msg.payload);
+    return {
+      uid: msg.id,
+      from: { name: fromMatch[1]?.replace(/"/g, "").trim() || void 0, email: fromMatch[2] || from },
+      to: [{ email: this.getHeader(msg, "To") }],
+      cc: this.getHeader(msg, "Cc") ? [{ email: this.getHeader(msg, "Cc") }] : void 0,
+      subject: this.getHeader(msg, "Subject"),
+      body,
+      html,
+      date: this.getHeader(msg, "Date"),
+      read: !(msg.labelIds || []).includes("UNREAD"),
+      flagged: (msg.labelIds || []).includes("STARRED"),
+      folder: (msg.labelIds || []).includes("INBOX") ? "inbox" : "other",
+      messageId: this.getHeader(msg, "Message-ID"),
+      inReplyTo: this.getHeader(msg, "In-Reply-To") || void 0,
+      references: this.getHeader(msg, "References") ? this.getHeader(msg, "References").split(/\s+/) : void 0,
+      attachments: []
+    };
+  }
+};
+
+// src/agenticmail/providers/imap.ts
+var IMAP_PRESETS = {
+  "microsoft365": { imapHost: "outlook.office365.com", imapPort: 993, smtpHost: "smtp.office365.com", smtpPort: 587 },
+  "office365": { imapHost: "outlook.office365.com", imapPort: 993, smtpHost: "smtp.office365.com", smtpPort: 587 },
+  "outlook": { imapHost: "outlook.office365.com", imapPort: 993, smtpHost: "smtp.office365.com", smtpPort: 587 },
+  "gmail": { imapHost: "imap.gmail.com", imapPort: 993, smtpHost: "smtp.gmail.com", smtpPort: 587 },
+  "google": { imapHost: "imap.gmail.com", imapPort: 993, smtpHost: "smtp.gmail.com", smtpPort: 587 },
+  "yahoo": { imapHost: "imap.mail.yahoo.com", imapPort: 993, smtpHost: "smtp.mail.yahoo.com", smtpPort: 465 },
+  "zoho": { imapHost: "imap.zoho.com", imapPort: 993, smtpHost: "smtp.zoho.com", smtpPort: 587 },
+  "fastmail": { imapHost: "imap.fastmail.com", imapPort: 993, smtpHost: "smtp.fastmail.com", smtpPort: 587 },
+  "icloud": { imapHost: "imap.mail.me.com", imapPort: 993, smtpHost: "smtp.mail.me.com", smtpPort: 587 }
+};
+function detectImapSettings(email) {
+  const domain = email.split("@")[1]?.toLowerCase();
+  if (!domain) return null;
+  for (const [key, preset] of Object.entries(IMAP_PRESETS)) {
+    if (domain.includes(key) || domain === "gmail.com" || domain === "outlook.com" || domain === "hotmail.com") {
+      if (domain === "gmail.com" || domain.endsWith(".google.com")) return IMAP_PRESETS.gmail;
+      if (domain === "outlook.com" || domain === "hotmail.com" || domain.endsWith(".onmicrosoft.com")) return IMAP_PRESETS.microsoft365;
+    }
+  }
+  return null;
+}
+var ImapEmailProvider = class {
+  provider = "imap";
+  identity = null;
+  // IMAP connection (lazy-loaded to avoid bundling the dep if not used)
+  imapClient = null;
+  smtpClient = null;
+  getIdentity() {
+    if (!this.identity) throw new Error("Not connected \u2014 call connect() first");
+    return this.identity;
+  }
+  // ─── Connection ─────────────────────────────────────
+  async connect(identity) {
+    const imapIdentity = identity;
+    if (!imapIdentity.imapHost) throw new Error("IMAP host is required");
+    if (!imapIdentity.smtpHost) throw new Error("SMTP host is required");
+    this.identity = imapIdentity;
+    try {
+      const { ImapFlow } = await import("imapflow");
+      this.imapClient = new ImapFlow({
+        host: imapIdentity.imapHost,
+        port: imapIdentity.imapPort || 993,
+        secure: true,
+        auth: {
+          user: imapIdentity.email,
+          pass: imapIdentity.password || imapIdentity.accessToken
+        },
+        logger: false
+      });
+      await this.imapClient.connect();
+    } catch (err) {
+      if (err.code === "ERR_MODULE_NOT_FOUND" || err.message?.includes("Cannot find")) {
+        console.warn("[imap-provider] imapflow not installed \u2014 IMAP operations will fail. Install with: npm install imapflow");
+        this.imapClient = null;
+      } else {
+        throw new Error(`Failed to connect to IMAP server ${imapIdentity.imapHost}: ${err.message}`);
+      }
+    }
+  }
+  async disconnect() {
+    if (this.imapClient) {
+      try {
+        await this.imapClient.logout();
+      } catch {
+      }
+      this.imapClient = null;
+    }
+    this.identity = null;
+  }
+  // ─── List / Read ────────────────────────────────────
+  async listMessages(folder, opts) {
+    if (!this.imapClient) throw new Error("IMAP not connected. Ensure imapflow is installed and connection succeeded.");
+    const limit = opts?.limit || 20;
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      const envelopes = [];
+      const status = await this.imapClient.status(folder || "INBOX", { messages: true });
+      const total = status.messages || 0;
+      const start = Math.max(1, total - (opts?.offset || 0) - limit + 1);
+      const end = total - (opts?.offset || 0);
+      if (start > end || end < 1) return [];
+      for await (const msg of this.imapClient.fetch(`${start}:${end}`, { envelope: true, flags: true, bodyStructure: true })) {
+        envelopes.push({
+          uid: String(msg.uid),
+          from: {
+            name: msg.envelope?.from?.[0]?.name || void 0,
+            email: msg.envelope?.from?.[0]?.address || ""
+          },
+          to: (msg.envelope?.to || []).map((t) => ({
+            name: t.name || void 0,
+            email: t.address || ""
+          })),
+          subject: msg.envelope?.subject || "",
+          date: msg.envelope?.date?.toISOString() || "",
+          read: msg.flags?.has("\\Seen") || false,
+          flagged: msg.flags?.has("\\Flagged") || false,
+          hasAttachments: msg.bodyStructure?.childNodes?.length > 1 || false
+        });
+      }
+      return envelopes.reverse();
+    } finally {
+      lock.release();
+    }
+  }
+  async readMessage(uid, folder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      const msg = await this.imapClient.fetchOne(uid, {
+        envelope: true,
+        flags: true,
+        source: true
+        // full RFC822 message
+      }, { uid: true });
+      if (!msg) throw new Error(`Message ${uid} not found`);
+      const source = msg.source?.toString("utf-8") || "";
+      const bodyMatch = source.match(/\r?\n\r?\n([\s\S]*)/);
+      const body = bodyMatch ? bodyMatch[1] : "";
+      return {
+        uid: String(msg.uid),
+        from: {
+          name: msg.envelope?.from?.[0]?.name || void 0,
+          email: msg.envelope?.from?.[0]?.address || ""
+        },
+        to: (msg.envelope?.to || []).map((t) => ({
+          name: t.name || void 0,
+          email: t.address || ""
+        })),
+        cc: (msg.envelope?.cc || []).map((c) => ({
+          name: c.name || void 0,
+          email: c.address || ""
+        })),
+        subject: msg.envelope?.subject || "",
+        body,
+        date: msg.envelope?.date?.toISOString() || "",
+        read: msg.flags?.has("\\Seen") || false,
+        flagged: msg.flags?.has("\\Flagged") || false,
+        folder: folder || "INBOX",
+        messageId: msg.envelope?.messageId || void 0,
+        inReplyTo: msg.envelope?.inReplyTo || void 0
+      };
+    } finally {
+      lock.release();
+    }
+  }
+  async searchMessages(criteria) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock("INBOX");
+    try {
+      const query = {};
+      if (criteria.from) query.from = criteria.from;
+      if (criteria.to) query.to = criteria.to;
+      if (criteria.subject) query.subject = criteria.subject;
+      if (criteria.text) query.body = criteria.text;
+      if (criteria.since) query.since = new Date(criteria.since);
+      if (criteria.before) query.before = new Date(criteria.before);
+      if (criteria.seen === true) query.seen = true;
+      if (criteria.seen === false) query.unseen = true;
+      const uids = await this.imapClient.search(query, { uid: true });
+      if (!uids.length) return [];
+      const envelopes = [];
+      const uidRange = uids.slice(-50).join(",");
+      for await (const msg of this.imapClient.fetch(uidRange, { envelope: true, flags: true }, { uid: true })) {
+        envelopes.push({
+          uid: String(msg.uid),
+          from: {
+            name: msg.envelope?.from?.[0]?.name || void 0,
+            email: msg.envelope?.from?.[0]?.address || ""
+          },
+          to: (msg.envelope?.to || []).map((t) => ({
+            name: t.name || void 0,
+            email: t.address || ""
+          })),
+          subject: msg.envelope?.subject || "",
+          date: msg.envelope?.date?.toISOString() || "",
+          read: msg.flags?.has("\\Seen") || false,
+          flagged: msg.flags?.has("\\Flagged") || false,
+          hasAttachments: false
+        });
+      }
+      return envelopes.reverse();
+    } finally {
+      lock.release();
+    }
+  }
+  async listFolders() {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const folders = [];
+    const mailboxes = await this.imapClient.list();
+    for (const mb of mailboxes) {
+      try {
+        const status = await this.imapClient.status(mb.path, { messages: true, unseen: true });
+        folders.push({
+          name: mb.name,
+          path: mb.path,
+          unread: status.unseen || 0,
+          total: status.messages || 0
+        });
+      } catch {
+        folders.push({ name: mb.name, path: mb.path, unread: 0, total: 0 });
+      }
+    }
+    return folders;
+  }
+  async createFolder(name) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    await this.imapClient.mailboxCreate(name);
+  }
+  // ─── Send (via SMTP) ───────────────────────────────
+  async send(options) {
+    const identity = this.getIdentity();
+    try {
+      const nodemailer = await import("nodemailer");
+      const transporter = nodemailer.createTransport({
+        host: identity.smtpHost,
+        port: identity.smtpPort || 587,
+        secure: (identity.smtpPort || 587) === 465,
+        auth: {
+          user: identity.email,
+          pass: identity.password || identity.accessToken
+        }
+      });
+      const result = await transporter.sendMail({
+        from: identity.email,
+        to: options.to,
+        cc: options.cc,
+        bcc: options.bcc,
+        subject: options.subject,
+        text: options.body,
+        html: options.html,
+        inReplyTo: options.inReplyTo,
+        references: options.references?.join(" "),
+        attachments: options.attachments?.map((a) => ({
+          filename: a.filename,
+          content: a.content,
+          contentType: a.contentType,
+          encoding: a.encoding
+        }))
+      });
+      return { messageId: result.messageId || `smtp-${Date.now()}` };
+    } catch (err) {
+      if (err.code === "ERR_MODULE_NOT_FOUND" || err.message?.includes("Cannot find")) {
+        throw new Error("nodemailer is required for SMTP sending. Install with: npm install nodemailer");
+      }
+      throw new Error(`SMTP send failed: ${err.message}`);
+    }
+  }
+  async reply(uid, body, replyAll = false) {
+    const original = await this.readMessage(uid);
+    const to = replyAll ? [original.from.email, ...(original.to || []).map((t) => t.email), ...(original.cc || []).map((c) => c.email)].filter((e) => e !== this.identity?.email).join(", ") : original.from.email;
+    return this.send({
+      to,
+      subject: original.subject.startsWith("Re:") ? original.subject : `Re: ${original.subject}`,
+      body,
+      inReplyTo: original.messageId,
+      references: original.references ? [...original.references, original.messageId] : original.messageId ? [original.messageId] : void 0
+    });
+  }
+  async forward(uid, to, body) {
+    const original = await this.readMessage(uid);
+    return this.send({
+      to,
+      subject: `Fwd: ${original.subject}`,
+      body: (body ? body + "\n\n" : "") + `---------- Forwarded message ----------
+From: ${original.from.email}
+Date: ${original.date}
+Subject: ${original.subject}
+
+` + original.body
+    });
+  }
+  // ─── Organize ───────────────────────────────────────
+  async moveMessage(uid, toFolder, _fromFolder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(_fromFolder || "INBOX");
+    try {
+      await this.imapClient.messageMove(uid, toFolder, { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
+  async deleteMessage(uid, folder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      await this.imapClient.messageDelete(uid, { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
+  async markRead(uid, folder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      await this.imapClient.messageFlagsAdd(uid, ["\\Seen"], { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
+  async markUnread(uid, folder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      await this.imapClient.messageFlagsRemove(uid, ["\\Seen"], { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
+  async flagMessage(uid, folder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      await this.imapClient.messageFlagsAdd(uid, ["\\Flagged"], { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
+  async unflagMessage(uid, folder) {
+    if (!this.imapClient) throw new Error("IMAP not connected");
+    const lock = await this.imapClient.getMailboxLock(folder || "INBOX");
+    try {
+      await this.imapClient.messageFlagsRemove(uid, ["\\Flagged"], { uid: true });
+    } finally {
+      lock.release();
+    }
+  }
+  // ─── Batch ──────────────────────────────────────────
+  async batchMarkRead(uids, folder) {
+    for (const uid of uids) await this.markRead(uid, folder);
+  }
+  async batchMarkUnread(uids, folder) {
+    for (const uid of uids) await this.markUnread(uid, folder);
+  }
+  async batchMove(uids, toFolder, fromFolder) {
+    for (const uid of uids) await this.moveMessage(uid, toFolder, fromFolder);
+  }
+  async batchDelete(uids, folder) {
+    for (const uid of uids) await this.deleteMessage(uid, folder);
+  }
+};
+
+// src/agenticmail/providers/index.ts
+function createEmailProvider(provider) {
+  switch (provider) {
+    case "microsoft":
+      return new MicrosoftEmailProvider();
+    case "google":
+      return new GoogleEmailProvider();
+    case "imap":
+      return new ImapEmailProvider();
+    default:
+      throw new Error(`Unknown email provider: ${provider}`);
+  }
+}
+
+// src/agenticmail/manager.ts
+var AgenticMailManager = class {
+  providers = /* @__PURE__ */ new Map();
+  identities = /* @__PURE__ */ new Map();
+  db;
+  constructor(opts) {
+    this.db = opts?.db;
+  }
+  setDb(db) {
+    this.db = db;
+  }
+  // ─── Agent Registration ─────────────────────────────
+  /**
+   * Register an agent's email identity from the org's OAuth/SSO.
+   * Called when an agent is created or when its OAuth token is refreshed.
+   */
+  async registerAgent(identity) {
+    this.identities.set(identity.agentId, identity);
+    const provider = createEmailProvider(identity.provider);
+    await provider.connect(identity);
+    this.providers.set(identity.agentId, provider);
+  }
+  /**
+   * Unregister an agent (on deletion or token revocation).
+   */
+  async unregisterAgent(agentId) {
+    const provider = this.providers.get(agentId);
+    if (provider) {
+      await provider.disconnect().catch(() => {
+      });
+      this.providers.delete(agentId);
+    }
+    this.identities.delete(agentId);
+  }
+  /**
+   * Get the email provider for an agent.
+   * Throws if agent is not registered.
+   */
+  getProvider(agentId) {
+    const provider = this.providers.get(agentId);
+    if (!provider) throw new Error(`Agent ${agentId} has no email provider registered. Ensure the agent has been connected via org OAuth.`);
+    return provider;
+  }
+  /**
+   * Get the email identity for an agent.
+   */
+  getIdentity(agentId) {
+    return this.identities.get(agentId);
+  }
+  /**
+   * Check if an agent has email access.
+   */
+  hasEmail(agentId) {
+    return this.providers.has(agentId);
+  }
+  // ─── Inter-Agent Messaging ──────────────────────────
+  // These use the enterprise DB directly, not email.
+  // Agents in the same org can message each other without email.
+  /**
+   * Send a message from one agent to another (internal, no email).
+   */
+  async sendAgentMessage(from, to, subject, body, priority = "normal") {
+    const msg = {
+      id: crypto.randomUUID(),
+      from,
+      to,
+      subject,
+      body,
+      priority,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      read: false
+    };
+    if (this.db) {
+      await this.db.execute(
+        `INSERT INTO agent_messages (id, from_agent, to_agent, subject, body, priority, created_at, read)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 0)`,
+        [msg.id, msg.from, msg.to, msg.subject, msg.body, msg.priority, msg.createdAt]
+      ).catch(() => {
+      });
+    }
+    return msg;
+  }
+  /**
+   * Get unread messages for an agent.
+   */
+  async getAgentMessages(agentId, opts) {
+    if (!this.db) return [];
+    try {
+      let sql = "SELECT * FROM agent_messages WHERE to_agent = ?";
+      const params = [agentId];
+      if (opts?.unreadOnly) {
+        sql += " AND read = 0";
+      }
+      sql += " ORDER BY created_at DESC LIMIT ?";
+      params.push(opts?.limit || 20);
+      const rows = await this.db.query(sql, params);
+      return rows.map((r) => ({
+        id: r.id,
+        from: r.from_agent,
+        to: r.to_agent,
+        subject: r.subject,
+        body: r.body,
+        priority: r.priority,
+        createdAt: r.created_at,
+        read: !!r.read
+      }));
+    } catch {
+      return [];
+    }
+  }
+  // ─── Task Management ────────────────────────────────
+  // Tasks also use the enterprise DB directly.
+  /**
+   * Create a task assigned to an agent.
+   */
+  async createTask(assigner, assignee, title, description, priority = "normal") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      id: crypto.randomUUID(),
+      assigner,
+      assignee,
+      title,
+      description,
+      status: "pending",
+      priority,
+      createdAt: now,
+      updatedAt: now
+    };
+    if (this.db) {
+      await this.db.execute(
+        `INSERT INTO agent_tasks (id, assigner, assignee, title, description, status, priority, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [task.id, task.assigner, task.assignee, task.title, task.description || null, task.status, task.priority, task.createdAt, task.updatedAt]
+      ).catch(() => {
+      });
+    }
+    return task;
+  }
+  /**
+   * Get tasks for an agent.
+   */
+  async getAgentTasks(agentId, direction = "incoming", status) {
+    if (!this.db) return [];
+    try {
+      const col = direction === "incoming" ? "assignee" : "assigner";
+      let sql = `SELECT * FROM agent_tasks WHERE ${col} = ?`;
+      const params = [agentId];
+      if (status) {
+        sql += " AND status = ?";
+        params.push(status);
+      }
+      sql += " ORDER BY created_at DESC LIMIT 50";
+      const rows = await this.db.query(sql, params);
+      return rows.map((r) => ({
+        id: r.id,
+        assigner: r.assigner,
+        assignee: r.assignee,
+        title: r.title,
+        description: r.description,
+        status: r.status,
+        priority: r.priority,
+        result: r.result ? JSON.parse(r.result) : void 0,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Update task status.
+   */
+  async updateTask(taskId, updates) {
+    if (!this.db) return;
+    const sets = ["updated_at = ?"];
+    const params = [(/* @__PURE__ */ new Date()).toISOString()];
+    if (updates.status) {
+      sets.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.result !== void 0) {
+      sets.push("result = ?");
+      params.push(JSON.stringify(updates.result));
+    }
+    params.push(taskId);
+    await this.db.execute(`UPDATE agent_tasks SET ${sets.join(", ")} WHERE id = ?`, params).catch(() => {
+    });
+  }
+  // ─── Lifecycle ──────────────────────────────────────
+  /**
+   * Get all registered agents and their email status.
+   */
+  getRegisteredAgents() {
+    const agents = [];
+    for (const [agentId, identity] of this.identities) {
+      agents.push({ agentId, email: identity.email, provider: identity.provider });
+    }
+    return agents;
+  }
+  /**
+   * Shutdown — disconnect all providers.
+   */
+  async shutdown() {
+    for (const provider of this.providers.values()) {
+      await provider.disconnect().catch(() => {
+      });
+    }
+    this.providers.clear();
+    this.identities.clear();
+  }
+};
+
+export {
+  MicrosoftEmailProvider,
+  GoogleEmailProvider,
+  IMAP_PRESETS,
+  detectImapSettings,
+  ImapEmailProvider,
+  createEmailProvider,
+  AgenticMailManager
+};