@pensar/apex 2.5.0 → 2.6.1-canary.025b1ecf

package/build/lib/chunk-zrbqn62x.js

@@ -0,0 +1,697 @@
+// src/core/agents/offSecAgent/tools/email/adapters.ts
+import { simpleParser } from "mailparser";
+import { auth as gauth, gmail_v1 } from "@googleapis/gmail";
+import { Client as GraphClient } from "@microsoft/microsoft-graph-client";
+import {
+  ImapFlow
+} from "imapflow";
+function resolveEmailAdapter2(inbox, resolver) {
+  return resolver?.(inbox) ?? createEmailAdapter2(inbox);
+}
+function createEmailAdapter2(inbox) {
+  switch (inbox.provider) {
+    case "gmail":
+      return new GmailAdapter(inbox.accessToken, inbox.refreshToken, inbox.clientId, inbox.clientSecret, inbox.tokenExpiry);
+    case "outlook":
+      return new OutlookAdapter(inbox.accessToken, inbox.refreshToken, inbox.clientId, inbox.clientSecret);
+    case "imap":
+      return new ImapAdapter(inbox);
+    case "http":
+      return new HttpAdapter(inbox);
+    case "pensar-managed":
+      throw new Error(`Inbox ${inbox.id} is pensar-managed; the host must supply an email adapter for it.`);
+    default:
+      throw new Error(`Unsupported email provider: ${inbox.provider}`);
+  }
+}
+function gmailErrorMessage(error) {
+  if (!(error instanceof Error))
+    return String(error);
+  const msg = error.message;
+  const res = error.response;
+  if (res?.data) {
+    const data = res.data;
+    if (data.error_description) {
+      return `Gmail API error: ${data.error} – ${data.error_description}`;
+    }
+    if (typeof res.data === "string") {
+      return `Gmail API error: ${msg} – ${res.data}`;
+    }
+  }
+  if (msg === "invalid_request" || msg === "invalid_grant") {
+    return `Gmail OAuth error: ${msg}. This usually means the access token has expired and the refresh token could not be used. Ensure clientId and clientSecret are provided in the inbox config.`;
+  }
+  return msg;
+}
+
+class GmailAdapter {
+  client;
+  constructor(accessToken, refreshToken, clientId, clientSecret, tokenExpiry) {
+    const oauth2 = new gauth.OAuth2(clientId, clientSecret);
+    oauth2.setCredentials({
+      access_token: accessToken,
+      refresh_token: refreshToken,
+      expiry_date: tokenExpiry
+    });
+    this.client = new gmail_v1.Gmail({ auth: oauth2 });
+  }
+  async listMessages(opts) {
+    try {
+      const q = opts.folder ? `in:${opts.folder}` : "in:inbox";
+      const res = await this.client.users.messages.list({
+        userId: "me",
+        q,
+        maxResults: opts.maxResults ?? 20,
+        pageToken: opts.pageToken
+      });
+      if (!res.data.messages?.length) {
+        return {
+          messages: [],
+          totalEstimate: res.data.resultSizeEstimate ?? 0
+        };
+      }
+      const summaries = await Promise.all(res.data.messages.map((m) => this.fetchSummary(m.id)));
+      return {
+        messages: summaries,
+        nextPageToken: res.data.nextPageToken ?? undefined,
+        totalEstimate: res.data.resultSizeEstimate ?? undefined
+      };
+    } catch (error) {
+      throw new Error(gmailErrorMessage(error), { cause: error });
+    }
+  }
+  async fetchSummary(id) {
+    const res = await this.client.users.messages.get({
+      userId: "me",
+      id,
+      format: "metadata",
+      metadataHeaders: ["From", "To", "Subject", "Date"]
+    });
+    return gmailToSummary(res.data);
+  }
+  async getMessage(messageId, _folder) {
+    try {
+      const res = await this.client.users.messages.get({
+        userId: "me",
+        id: messageId,
+        format: "full"
+      });
+      return gmailToFull(res.data);
+    } catch (error) {
+      throw new Error(gmailErrorMessage(error), { cause: error });
+    }
+  }
+  async searchMessages(opts) {
+    try {
+      const res = await this.client.users.messages.list({
+        userId: "me",
+        q: opts.query,
+        maxResults: opts.maxResults ?? 20,
+        pageToken: opts.pageToken
+      });
+      if (!res.data.messages?.length) {
+        return {
+          messages: [],
+          totalEstimate: res.data.resultSizeEstimate ?? 0
+        };
+      }
+      const summaries = await Promise.all(res.data.messages.map((m) => this.fetchSummary(m.id)));
+      return {
+        messages: summaries,
+        nextPageToken: res.data.nextPageToken ?? undefined,
+        totalEstimate: res.data.resultSizeEstimate ?? undefined
+      };
+    } catch (error) {
+      throw new Error(gmailErrorMessage(error), { cause: error });
+    }
+  }
+  async getAttachments(messageId, _folder) {
+    const res = await this.client.users.messages.get({
+      userId: "me",
+      id: messageId,
+      format: "full"
+    });
+    return extractGmailAttachments(res.data);
+  }
+  async getAttachmentContent(messageId, attachmentId, _folder) {
+    const attRes = await this.client.users.messages.attachments.get({
+      userId: "me",
+      messageId,
+      id: attachmentId
+    });
+    const attachments = await this.getAttachments(messageId);
+    const meta = attachments.find((a) => a.id === attachmentId);
+    return {
+      filename: meta?.filename ?? "attachment",
+      mimeType: meta?.mimeType ?? "application/octet-stream",
+      base64Content: attRes.data.data ?? ""
+    };
+  }
+  async markAsRead(messageId, _folder) {
+    await this.client.users.messages.modify({
+      userId: "me",
+      id: messageId,
+      requestBody: { removeLabelIds: ["UNREAD"] }
+    });
+  }
+}
+function hdr(msg, name) {
+  return msg.payload?.headers?.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? "";
+}
+function splitAddressList(header) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0;i < header.length; i++) {
+    const ch = header[i];
+    if (ch === '"' && (i === 0 || header[i - 1] !== "\\")) {
+      inQuotes = !inQuotes;
+      current += ch;
+    } else if (ch === "," && !inQuotes) {
+      const trimmed = current.trim();
+      if (trimmed)
+        result.push(trimmed);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed)
+    result.push(trimmed);
+  return result;
+}
+function gmailToSummary(msg) {
+  return {
+    id: msg.id ?? "",
+    from: hdr(msg, "From"),
+    to: splitAddressList(hdr(msg, "To")),
+    subject: hdr(msg, "Subject"),
+    date: hdr(msg, "Date"),
+    snippet: msg.snippet ?? "",
+    isRead: !msg.labelIds?.includes("UNREAD"),
+    hasAttachments: hasAttachmentParts(msg.payload?.parts),
+    labels: msg.labelIds ?? undefined
+  };
+}
+function gmailToFull(msg) {
+  return {
+    ...gmailToSummary(msg),
+    body: extractGmailBody(msg),
+    cc: splitAddressList(hdr(msg, "Cc")),
+    replyTo: hdr(msg, "Reply-To") || undefined
+  };
+}
+function extractGmailBody(msg) {
+  const findBody = (parts) => {
+    if (!parts)
+      return "";
+    for (const part of parts) {
+      if (part.mimeType === "text/plain" && part.body?.data) {
+        return Buffer.from(part.body.data, "base64url").toString("utf-8");
+      }
+      if (part.parts) {
+        const nested = findBody(part.parts);
+        if (nested)
+          return nested;
+      }
+    }
+    for (const part of parts) {
+      if (part.mimeType === "text/html" && part.body?.data) {
+        return Buffer.from(part.body.data, "base64url").toString("utf-8");
+      }
+    }
+    return "";
+  };
+  if (msg.payload?.parts)
+    return findBody(msg.payload.parts);
+  if (msg.payload?.body?.data)
+    return Buffer.from(msg.payload.body.data, "base64url").toString("utf-8");
+  return "";
+}
+function hasAttachmentParts(parts) {
+  if (!parts)
+    return false;
+  return parts.some((p) => p.filename && p.filename.length > 0 || hasAttachmentParts(p.parts ?? undefined));
+}
+function extractGmailAttachments(msg) {
+  const result = [];
+  const walk = (parts) => {
+    if (!parts)
+      return;
+    for (const part of parts) {
+      if (part.filename && part.filename.length > 0 && part.body?.attachmentId) {
+        result.push({
+          id: part.body.attachmentId,
+          filename: part.filename,
+          mimeType: part.mimeType ?? "application/octet-stream",
+          size: part.body.size ?? 0
+        });
+      }
+      if (part.parts)
+        walk(part.parts);
+    }
+  };
+  walk(msg.payload?.parts ?? undefined);
+  return result;
+}
+function graphPathSegment(value) {
+  const stripped = value.replace(/\.\.|[/\\]/g, "");
+  return encodeURIComponent(stripped);
+}
+
+class OutlookAdapter {
+  accessToken;
+  refreshToken;
+  clientId;
+  clientSecret;
+  tokenExpiresAt = 0;
+  refreshPromise = null;
+  client;
+  constructor(accessToken, refreshToken, clientId, clientSecret) {
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken;
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.tokenExpiresAt = OutlookAdapter.parseJwtExpiry(accessToken);
+    this.client = GraphClient.init({
+      authProvider: (done) => {
+        this.ensureFreshToken().then(() => done(null, this.accessToken)).catch(() => done(null, this.accessToken));
+      }
+    });
+  }
+  static parseJwtExpiry(token) {
+    try {
+      const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString());
+      return typeof payload.exp === "number" ? payload.exp : 0;
+    } catch {
+      return 0;
+    }
+  }
+  async ensureFreshToken() {
+    const nowSec = Math.floor(Date.now() / 1000);
+    const bufferSec = 300;
+    if (this.tokenExpiresAt > 0 && nowSec < this.tokenExpiresAt - bufferSec) {
+      return;
+    }
+    if (!this.clientId || !this.refreshToken)
+      return;
+    if (this.refreshPromise)
+      return this.refreshPromise;
+    this.refreshPromise = (async () => {
+      try {
+        const params = {
+          client_id: this.clientId,
+          grant_type: "refresh_token",
+          refresh_token: this.refreshToken,
+          scope: "https://graph.microsoft.com/.default offline_access"
+        };
+        if (this.clientSecret) {
+          params.client_secret = this.clientSecret;
+        }
+        const body = new URLSearchParams(params);
+        const res = await fetch("https://login.microsoftonline.com/common/oauth2/v2.0/token", { method: "POST", body });
+        if (!res.ok)
+          return;
+        const data = await res.json();
+        if (data.access_token) {
+          this.accessToken = data.access_token;
+          this.tokenExpiresAt = OutlookAdapter.parseJwtExpiry(data.access_token);
+        }
+        if (data.refresh_token) {
+          this.refreshToken = data.refresh_token;
+        }
+      } finally {
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  async listMessages(opts) {
+    const top = opts.maxResults ?? 20;
+    const folder = opts.folder ?? "inbox";
+    let req = this.client.api(`/me/mailFolders/${graphPathSegment(folder)}/messages`).top(top).orderby("receivedDateTime desc").select("id,from,toRecipients,subject,receivedDateTime,bodyPreview,isRead,hasAttachments");
+    if (opts.pageToken) {
+      req = this.client.api(opts.pageToken);
+    }
+    const data = await req.get();
+    return {
+      messages: data.value.map(outlookToSummary),
+      nextPageToken: data["@odata.nextLink"] ?? undefined,
+      totalEstimate: data["@odata.count"] ?? undefined
+    };
+  }
+  async getMessage(messageId, _folder) {
+    const msg = await this.client.api(`/me/messages/${graphPathSegment(messageId)}`).get();
+    return outlookToFull(msg);
+  }
+  async searchMessages(opts) {
+    const top = opts.maxResults ?? 20;
+    let req = this.client.api("/me/messages").search(opts.query).top(top).select("id,from,toRecipients,subject,receivedDateTime,bodyPreview,isRead,hasAttachments");
+    if (opts.pageToken) {
+      req = this.client.api(opts.pageToken);
+    }
+    const data = await req.get();
+    return {
+      messages: data.value.map(outlookToSummary),
+      nextPageToken: data["@odata.nextLink"] ?? undefined,
+      totalEstimate: data["@odata.count"] ?? undefined
+    };
+  }
+  async getAttachments(messageId, _folder) {
+    const data = await this.client.api(`/me/messages/${graphPathSegment(messageId)}/attachments`).get();
+    return data.value.map((a) => ({
+      id: a.id,
+      filename: a.name,
+      mimeType: a.contentType,
+      size: a.size
+    }));
+  }
+  async getAttachmentContent(messageId, attachmentId, _folder) {
+    const data = await this.client.api(`/me/messages/${graphPathSegment(messageId)}/attachments/${graphPathSegment(attachmentId)}`).get();
+    return {
+      filename: data.name,
+      mimeType: data.contentType,
+      base64Content: data.contentBytes
+    };
+  }
+  async markAsRead(messageId, _folder) {
+    await this.client.api(`/me/messages/${graphPathSegment(messageId)}`).patch({ isRead: true });
+  }
+}
+function fmtAddr(a) {
+  return a.name ? `${a.name} <${a.address}>` : a.address;
+}
+function outlookToSummary(msg) {
+  return {
+    id: msg.id,
+    from: msg.from?.emailAddress ? fmtAddr(msg.from.emailAddress) : "",
+    to: (msg.toRecipients ?? []).map((r) => fmtAddr(r.emailAddress)),
+    subject: msg.subject ?? "",
+    date: msg.receivedDateTime ?? "",
+    snippet: msg.bodyPreview ?? "",
+    isRead: msg.isRead ?? false,
+    hasAttachments: msg.hasAttachments ?? false
+  };
+}
+function outlookToFull(msg) {
+  return {
+    ...outlookToSummary(msg),
+    body: msg.body?.content ?? "",
+    cc: (msg.ccRecipients ?? []).map((r) => fmtAddr(r.emailAddress)),
+    replyTo: msg.replyTo?.[0]?.emailAddress?.address ?? undefined
+  };
+}
+
+class ImapAdapter {
+  cfg;
+  constructor(inbox) {
+    this.cfg = {
+      host: inbox.imapHost,
+      port: inbox.imapPort,
+      user: inbox.username,
+      pass: inbox.password,
+      tls: inbox.tls
+    };
+  }
+  async connect() {
+    const client = new ImapFlow({
+      host: this.cfg.host,
+      port: this.cfg.port,
+      secure: this.cfg.tls,
+      auth: { user: this.cfg.user, pass: this.cfg.pass },
+      logger: false
+    });
+    await client.connect();
+    return client;
+  }
+  async listMessages(opts) {
+    const client = await this.connect();
+    try {
+      const folder = opts.folder ?? "INBOX";
+      const max = opts.maxResults ?? 20;
+      const offset = opts.pageToken ? parseInt(opts.pageToken, 10) : 0;
+      const lock = await client.getMailboxLock(folder);
+      try {
+        const status = await client.status(folder, { messages: true });
+        const total = status.messages ?? 0;
+        if (total === 0 || offset >= total) {
+          return { messages: [], totalEstimate: total };
+        }
+        const start = Math.max(1, total - offset - max + 1);
+        const end = Math.max(1, total - offset);
+        const range = `${start}:${end}`;
+        const messages = [];
+        for await (const msg of client.fetch(range, {
+          envelope: true,
+          flags: true,
+          bodyStructure: true
+        })) {
+          const env = msg.envelope;
+          messages.push({
+            id: String(msg.uid),
+            from: env?.from?.[0] ? fmtImapAddr(env.from[0]) : "",
+            to: (env?.to ?? []).map(fmtImapAddr),
+            subject: env?.subject ?? "",
+            date: env?.date?.toISOString() ?? "",
+            snippet: "",
+            isRead: msg.flags?.has("\\Seen") ?? false,
+            hasAttachments: hasImapAttachments(msg.bodyStructure)
+          });
+        }
+        messages.reverse();
+        const nextOffset = offset + max;
+        return {
+          messages,
+          nextPageToken: nextOffset < total ? String(nextOffset) : undefined,
+          totalEstimate: total
+        };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout();
+    }
+  }
+  async getMessage(messageId, folder) {
+    const client = await this.connect();
+    try {
+      const lock = await client.getMailboxLock(folder ?? "INBOX");
+      try {
+        const uid = parseInt(messageId, 10);
+        let result = null;
+        for await (const msg of client.fetch({ uid }, {
+          envelope: true,
+          flags: true,
+          bodyStructure: true,
+          source: true
+        })) {
+          const env = msg.envelope;
+          if (!msg.source)
+            continue;
+          const parsed = await simpleParser(msg.source);
+          result = {
+            id: String(msg.uid),
+            from: env?.from?.[0] ? fmtImapAddr(env.from[0]) : "",
+            to: (env?.to ?? []).map(fmtImapAddr),
+            subject: env?.subject ?? "",
+            date: env?.date?.toISOString() ?? "",
+            snippet: (parsed.text ?? "").slice(0, 200),
+            isRead: msg.flags?.has("\\Seen") ?? false,
+            hasAttachments: (parsed.attachments?.length ?? 0) > 0,
+            body: truncate(parsed.text || parsed.html || "", 50000),
+            cc: (env?.cc ?? []).map(fmtImapAddr),
+            replyTo: env?.replyTo?.[0]?.address ?? undefined
+          };
+        }
+        if (!result)
+          throw new Error(`Message UID ${messageId} not found`);
+        return result;
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout();
+    }
+  }
+  async searchMessages(opts) {
+    const client = await this.connect();
+    try {
+      const lock = await client.getMailboxLock(opts.folder ?? "INBOX");
+      try {
+        const uids = await client.search({ body: opts.query });
+        if (!uids || uids.length === 0) {
+          return { messages: [], totalEstimate: 0 };
+        }
+        const total = uids.length;
+        const max = opts.maxResults ?? 20;
+        const page = uids.slice(-max).reverse();
+        const messages = [];
+        for await (const msg of client.fetch({ uid: page.join(",") }, { envelope: true, flags: true, bodyStructure: true })) {
+          const env = msg.envelope;
+          messages.push({
+            id: String(msg.uid),
+            from: env?.from?.[0] ? fmtImapAddr(env.from[0]) : "",
+            to: (env?.to ?? []).map(fmtImapAddr),
+            subject: env?.subject ?? "",
+            date: env?.date?.toISOString() ?? "",
+            snippet: "",
+            isRead: msg.flags?.has("\\Seen") ?? false,
+            hasAttachments: hasImapAttachments(msg.bodyStructure)
+          });
+        }
+        return { messages, totalEstimate: total };
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout();
+    }
+  }
+  async getAttachments(messageId, folder) {
+    const client = await this.connect();
+    try {
+      const lock = await client.getMailboxLock(folder ?? "INBOX");
+      try {
+        const uid = parseInt(messageId, 10);
+        for await (const msg of client.fetch({ uid }, { source: true })) {
+          if (!msg.source)
+            continue;
+          const parsed = await simpleParser(msg.source);
+          return (parsed.attachments ?? []).map((att, i) => ({
+            id: att.checksum ?? String(i),
+            filename: att.filename ?? `attachment_${i}`,
+            mimeType: att.contentType ?? "application/octet-stream",
+            size: att.size ?? 0
+          }));
+        }
+        return [];
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout();
+    }
+  }
+  async getAttachmentContent(messageId, attachmentId, folder) {
+    const client = await this.connect();
+    try {
+      const lock = await client.getMailboxLock(folder ?? "INBOX");
+      try {
+        const uid = parseInt(messageId, 10);
+        for await (const msg of client.fetch({ uid }, { source: true })) {
+          if (!msg.source)
+            continue;
+          const parsed = await simpleParser(msg.source);
+          const att = (parsed.attachments ?? []).find((a, i) => (a.checksum ?? String(i)) === attachmentId);
+          if (!att)
+            throw new Error(`Attachment ${attachmentId} not found`);
+          return {
+            filename: att.filename ?? "attachment",
+            mimeType: att.contentType ?? "application/octet-stream",
+            base64Content: att.content.toString("base64")
+          };
+        }
+        throw new Error(`Message UID ${messageId} not found`);
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout();
+    }
+  }
+  async markAsRead(messageId, folder) {
+    const client = await this.connect();
+    try {
+      const lock = await client.getMailboxLock(folder ?? "INBOX");
+      try {
+        await client.messageFlagsAdd({ uid: parseInt(messageId, 10) }, [
+          "\\Seen"
+        ]);
+      } finally {
+        lock.release();
+      }
+    } finally {
+      await client.logout();
+    }
+  }
+}
+function fmtImapAddr(a) {
+  return `${a.name ?? ""} <${a.address ?? ""}>`.trim();
+}
+function hasImapAttachments(bodyStructure) {
+  if (!bodyStructure)
+    return false;
+  if (bodyStructure.disposition === "attachment")
+    return true;
+  if (bodyStructure.childNodes) {
+    return bodyStructure.childNodes.some(hasImapAttachments);
+  }
+  return false;
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max)}
+
+(truncated)` : s;
+}
+
+class HttpAdapter {
+  endpoint;
+  token;
+  address;
+  constructor(inbox) {
+    this.endpoint = inbox.endpoint.replace(/\/+$/, "");
+    this.token = inbox.token;
+    this.address = inbox.emailAddress;
+  }
+  async get(path, params) {
+    const url = new URL(`${this.endpoint}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.token}` }
+    });
+    if (!res.ok) {
+      throw new Error(`Mailbox HTTP error ${res.status} ${res.statusText} for ${path}`);
+    }
+    return await res.json();
+  }
+  async listMessages(opts) {
+    const params = { address: this.address };
+    if (opts.maxResults !== undefined)
+      params.limit = String(opts.maxResults);
+    if (opts.pageToken)
+      params.cursor = opts.pageToken;
+    const data = await this.get("/messages", params);
+    return { messages: data.messages, nextPageToken: data.nextCursor };
+  }
+  async searchMessages(opts) {
+    const params = {
+      address: this.address,
+      q: opts.query
+    };
+    if (opts.maxResults !== undefined)
+      params.limit = String(opts.maxResults);
+    if (opts.pageToken)
+      params.cursor = opts.pageToken;
+    const data = await this.get("/messages", params);
+    return { messages: data.messages, nextPageToken: data.nextCursor };
+  }
+  async getMessage(messageId, _folder) {
+    return this.get(`/messages/${encodeURIComponent(messageId)}`);
+  }
+  async getAttachments(_messageId, _folder) {
+    return [];
+  }
+  async getAttachmentContent(_messageId, _attachmentId, _folder) {
+    throw new Error("Attachments are not supported by the http mailbox provider");
+  }
+  markAsRead(_messageId, _folder) {
+    return Promise.resolve();
+  }
+}
+
+export { resolveEmailAdapter2, createEmailAdapter2 };