agent-inbox 0.2.4 → 0.2.5

package/test/mail/full-flow-e2e.test.ts

@@ -1,200 +0,0 @@
-/**
- * Full-flow mail e2e — the entire chain over real SMTP sockets.
- *
- * Two independent agent-inbox "nodes" (each: storage + router + gateway + SMTP
- * transport) stand in for two organizations. Node A hosts alice@a.test, node B
- * hosts bob@b.test; each node's outbound relay points at the other's inbound
- * listener. We then exercise:
- *
- *   1. alice sends to bob@b.test
- *      → routerA → gatewayA → SMTP socket → gatewayB → routerB → bob's inbox
- *   2. bob replies to alice@a.test (in_reply_to the received message)
- *      → routerB → gatewayB → SMTP socket → gatewayA → routerA → alice's inbox
- *
- * Assertions prove ingestion, recipient resolution, delivered-marking, and
- * end-to-end RFC threading correlation across real wire transport.
- *
- * Skipped if the optional SMTP libs are not installed.
- */
-
-import { describe, it, expect, afterEach } from "vitest";
-import { EventEmitter } from "node:events";
-import { InMemoryStorage } from "../../src/storage/memory.js";
-import { MessageRouter } from "../../src/router/message-router.js";
-import { MailGateway } from "../../src/mail/mail-gateway.js";
-import { SmtpTransport } from "../../src/mail/smtp-transport.js";
-import type { Message } from "../../src/types.js";
-
-const haveLibs = await Promise.all([
-  import("smtp-server").then(() => true).catch(() => false),
-  import("nodemailer").then(() => true).catch(() => false),
-  import("mailparser").then(() => true).catch(() => false),
-]).then((r) => r.every(Boolean));
-
-const randomPort = () => 30000 + Math.floor(Math.random() * 5000);
-const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-async function waitFor(
-  fn: () => boolean,
-  timeoutMs = 4000,
-  stepMs = 20
-): Promise<void> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (fn()) return;
-    await sleep(stepMs);
-  }
-  throw new Error("waitFor timed out");
-}
-
-interface Node {
-  storage: InMemoryStorage;
-  router: MessageRouter;
-  gateway: MailGateway;
-  events: EventEmitter;
-}
-
-function makeNode(opts: {
-  listenPort: number;
-  relayPort: number;
-  localDomain: string;
-  routableDomain: string;
-  agentId: string;
-  agentAddress: string;
-}): Node {
-  const storage = new InMemoryStorage();
-  const events = new EventEmitter();
-  const router = new MessageRouter(storage, events, "default");
-  const transport = new SmtpTransport({
-    listenPort: opts.listenPort,
-    relay: { host: "127.0.0.1", port: opts.relayPort, secure: false },
-  });
-  const gateway = new MailGateway({
-    transport,
-    storage,
-    router,
-    events,
-    config: {
-      identity: {
-        localDomains: [opts.localDomain],
-        mappings: [{ agentId: opts.agentId, address: opts.agentAddress }],
-      },
-      routableDomains: [opts.routableDomain],
-      messageIdDomain: opts.localDomain,
-    },
-  });
-  router.setMail(gateway);
-  return { storage, router, gateway, events };
-}
-
-describe.skipIf(!haveLibs)("mail full-flow e2e (two nodes over real SMTP)", () => {
-  const nodes: Node[] = [];
-  afterEach(async () => {
-    for (const n of nodes) await n.gateway.stop().catch(() => {});
-    nodes.length = 0;
-  });
-
-  it("delivers agent→external→agent and threads the reply back", async () => {
-    const portA = randomPort();
-    const portB = randomPort();
-
-    const A = makeNode({
-      listenPort: portA,
-      relayPort: portB, // A sends to B
-      localDomain: "a.test",
-      routableDomain: "b.test",
-      agentId: "alice",
-      agentAddress: "alice@a.test",
-    });
-    const B = makeNode({
-      listenPort: portB,
-      relayPort: portA, // B sends to A
-      localDomain: "b.test",
-      routableDomain: "a.test",
-      agentId: "bob",
-      agentAddress: "bob@b.test",
-    });
-    nodes.push(A, B);
-    await A.gateway.start();
-    await B.gateway.start();
-
-    // --- 1. alice → bob@b.test ------------------------------------------
-    const outgoing: Message = await A.router.routeMessage({
-      from: "alice",
-      to: "bob@b.test",
-      subject: "Status check",
-      payload: "How is the deploy going?",
-    });
-
-    // Lands in bob's inbox on node B (commit-before-ACK means it's committed
-    // by the time the SMTP 250 returns, but poll to be socket-timing-safe).
-    await waitFor(() => B.storage.getInbox("bob").length === 1);
-    const bobMsg = B.storage.getInbox("bob")[0];
-    expect(bobMsg.sender_id).toBe("alice@a.test");
-    expect(bobMsg.recipients[0].agent_id).toBe("bob");
-    expect(bobMsg.subject).toBe("Status check");
-    // SMTP/MIME normalizes bodies with a trailing newline — trim for comparison.
-    expect((bobMsg.content as { text: string }).text.trim()).toBe(
-      "How is the deploy going?"
-    );
-    // B recorded the RFC Message-ID for later reply correlation.
-    expect(bobMsg.metadata.rfcMessageId).toBe(`<${outgoing.id}@a.test>`);
-
-    // A marked alice's outbound recipient delivered after B ACKed.
-    await waitFor(
-      () => !!A.storage.getMessage(outgoing.id)?.recipients[0].delivered_at
-    );
-
-    // --- 2. bob replies → alice@a.test ----------------------------------
-    await B.router.routeMessage({
-      from: "bob",
-      to: "alice@a.test",
-      subject: "Re: Status check",
-      payload: "Deploy is green.",
-      inReplyTo: bobMsg.id,
-    });
-
-    await waitFor(() => A.storage.getInbox("alice").length === 1);
-    const aliceReply = A.storage.getInbox("alice")[0];
-    expect(aliceReply.sender_id).toBe("bob@b.test");
-    expect((aliceReply.content as { text: string }).text.trim()).toBe(
-      "Deploy is green."
-    );
-    // The reply carries In-Reply-To = the original RFC Message-ID...
-    expect(aliceReply.metadata.rfcInReplyTo).toBe(`<${outgoing.id}@a.test>`);
-    // ...and because A sent the original, it correlates the reply back to the
-    // original inbox message id — full round-trip threading over real SMTP.
-    expect(aliceReply.in_reply_to).toBe(outgoing.id);
-  });
-
-  it("queues for durable retry when the relay is unreachable", async () => {
-    // Node A's relay points at a dead port. A real connection-refused on send
-    // classifies as transient, so the message goes to the durable retry queue
-    // rather than bouncing — exercising the failure path over a real socket.
-    const portA = randomPort();
-    const deadPort = randomPort();
-    const A = makeNode({
-      listenPort: portA,
-      relayPort: deadPort, // nothing is listening here
-      localDomain: "a.test",
-      routableDomain: "b.test",
-      agentId: "alice",
-      agentAddress: "alice@a.test",
-    });
-    nodes.push(A);
-    await A.gateway.start();
-
-    const queued: unknown[] = [];
-    A.events.on("mail.queued", (e) => queued.push(e));
-
-    await A.router.routeMessage({
-      from: "alice",
-      to: "bob@b.test",
-      payload: "will not connect",
-    });
-
-    // Connection refused → transient → queued for durable retry.
-    await waitFor(() => queued.length === 1);
-    expect(A.gateway.queue.size("mail")).toBe(1);
-  });
-});

package/test/mail/mail-gateway.test.ts

@@ -1,419 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { EventEmitter } from "node:events";
-import { InMemoryStorage } from "../../src/storage/memory.js";
-import { MessageRouter } from "../../src/router/message-router.js";
-import { MailGateway, type MailGatewayConfig } from "../../src/mail/mail-gateway.js";
-import { MockMailTransport, makeInboundMail } from "./mock-mail.js";
-import type { Message } from "../../src/types.js";
-
-function setup(configOver: Partial<MailGatewayConfig> = {}) {
-  const storage = new InMemoryStorage();
-  const events = new EventEmitter();
-  const router = new MessageRouter(storage, events);
-  const transport = new MockMailTransport();
-  const config: MailGatewayConfig = {
-    identity: {
-      localDomains: ["example.com"],
-      mappings: [{ agentId: "alice", address: "alice@example.com" }],
-    },
-    routableDomains: ["external.org"],
-    ...configOver,
-  };
-  const gateway = new MailGateway({ transport, storage, router, events, config });
-  router.setMail(gateway);
-  return { storage, events, router, transport, gateway };
-}
-
-function capture(events: EventEmitter, name: string): unknown[] {
-  const seen: unknown[] = [];
-  events.on(name, (e) => seen.push(e));
-  return seen;
-}
-
-function outboundMessage(over: Partial<Message> = {}): Message {
-  return {
-    id: "M1",
-    scope: "default",
-    sender_id: "alice",
-    recipients: [{ agent_id: "user@external.org", kind: "to" }],
-    subject: "hi",
-    content: { type: "text", text: "hello" },
-    importance: "normal",
-    metadata: {},
-    created_at: new Date().toISOString(),
-    ...over,
-  };
-}
-
-describe("MailGateway ingress", () => {
-  it("ingests inbound mail into the recipient's inbox", async () => {
-    const { gateway, storage, events } = setup();
-    const received = capture(events, "mail.received");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        from: { address: "ext@other.org" },
-        to: [{ address: "alice@example.com" }],
-        subject: "question",
-        text: "what's up",
-        headers: { messageId: "<q1@other.org>", raw: {} },
-      })
-    );
-
-    const inbox = storage.getInbox("alice");
-    expect(inbox).toHaveLength(1);
-    expect(inbox[0].subject).toBe("question");
-    expect(inbox[0].sender_id).toBe("ext@other.org");
-    expect(received).toHaveLength(1);
-  });
-
-  it("dedups a redelivered Message-ID (ingests once)", async () => {
-    const { gateway, storage, events } = setup();
-    const dup = capture(events, "mail.duplicate");
-    const mail = makeInboundMail({
-      to: [{ address: "alice@example.com" }],
-      headers: { messageId: "<same@x>", raw: {} },
-    });
-
-    await gateway.handleInbound(mail);
-    await gateway.handleInbound(mail);
-
-    expect(storage.getInbox("alice")).toHaveLength(1);
-    expect(dup).toHaveLength(1);
-  });
-
-  it("rejects oversize inbound mail", async () => {
-    const { gateway, storage, events } = setup({ maxMessageBytes: 10 });
-    const rejected = capture(events, "mail.rejected");
-
-    await gateway.handleInbound(
-      makeInboundMail({ to: [{ address: "alice@example.com" }], sizeBytes: 999 })
-    );
-
-    expect(storage.getInbox("alice")).toHaveLength(0);
-    expect(rejected).toEqual([
-      expect.objectContaining({ reason: "size-exceeded" }),
-    ]);
-  });
-
-  it("rejects senders outside the allow-list", async () => {
-    const { gateway, events } = setup({ allowedSenderDomains: ["trusted.org"] });
-    const rejected = capture(events, "mail.rejected");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        from: { address: "spammer@evil.net" },
-        to: [{ address: "alice@example.com" }],
-      })
-    );
-
-    expect(rejected).toEqual([
-      expect.objectContaining({ reason: "sender-not-allowed" }),
-    ]);
-  });
-
-  it("rejects DMARC failures when configured", async () => {
-    const { gateway, events } = setup({ rejectDmarcFail: true });
-    const rejected = capture(events, "mail.rejected");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        authResults: { spf: "fail", dkim: "fail", dmarc: "fail" },
-      })
-    );
-
-    expect(rejected).toEqual([
-      expect.objectContaining({ reason: "dmarc-fail" }),
-    ]);
-  });
-
-  it("rejects mail with no resolvable local recipient", async () => {
-    const { gateway, events } = setup();
-    const rejected = capture(events, "mail.rejected");
-
-    await gateway.handleInbound(
-      makeInboundMail({ to: [{ address: "ghost@example.com" }] })
-    );
-
-    expect(rejected).toEqual([
-      expect.objectContaining({ reason: "no-local-recipient" }),
-    ]);
-  });
-
-  it("rejects mail with too many attachments", async () => {
-    const { gateway, storage, events } = setup({ maxAttachments: 1 });
-    const rejected = capture(events, "mail.rejected");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        attachments: [
-          { contentType: "text/plain", contentRef: "r1", sizeBytes: 1 },
-          { contentType: "text/plain", contentRef: "r2", sizeBytes: 1 },
-        ],
-      })
-    );
-
-    expect(storage.getInbox("alice")).toHaveLength(0);
-    expect(rejected).toEqual([
-      expect.objectContaining({ reason: "too-many-attachments" }),
-    ]);
-  });
-});
-
-describe("MailGateway rate limiting", () => {
-  it("NACKs (throws) inbound over the per-sender-domain limit", async () => {
-    const { gateway, storage } = setup({
-      rateLimit: { windowMs: 60_000, perSenderDomain: 2 },
-    });
-    let n = 0;
-    const mail = () =>
-      makeInboundMail({
-        from: { address: "ext@flood.org" },
-        to: [{ address: "alice@example.com" }],
-        headers: { messageId: `<flood-${n++}@flood.org>`, raw: {} },
-      });
-
-    await gateway.handleInbound(mail());
-    await gateway.handleInbound(mail());
-    // Third within the window is rejected with a transient NACK.
-    await expect(gateway.handleInbound(mail())).rejects.toThrow(/rate limit/i);
-    expect(storage.getInbox("alice")).toHaveLength(2);
-  });
-
-  it("NACKs inbound over the global limit and emits an event", async () => {
-    const { gateway, events } = setup({
-      rateLimit: { windowMs: 60_000, global: 1 },
-    });
-    const limited = capture(events, "mail.rate_limited");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        from: { address: "a@one.org" },
-        to: [{ address: "alice@example.com" }],
-      })
-    );
-    await expect(
-      gateway.handleInbound(
-        makeInboundMail({
-          from: { address: "b@two.org" },
-          to: [{ address: "alice@example.com" }],
-        })
-      )
-    ).rejects.toThrow(/rate limit/i);
-    expect(limited).toEqual([expect.objectContaining({ scope: "global" })]);
-  });
-
-  it("does not rate limit when unconfigured", async () => {
-    const { gateway, storage } = setup();
-    for (let i = 0; i < 10; i++) {
-      await gateway.handleInbound(
-        makeInboundMail({
-          to: [{ address: "alice@example.com" }],
-          headers: { messageId: `<m${i}@x>`, raw: {} },
-        })
-      );
-    }
-    expect(storage.getInbox("alice")).toHaveLength(10);
-  });
-});
-
-describe("MailGateway egress", () => {
-  it("renders and delivers a message, marking recipients delivered", async () => {
-    const { gateway, storage, transport, events } = setup();
-    await transport.start();
-    const sent = capture(events, "mail.sent");
-    const msg = outboundMessage();
-    storage.putMessage(msg);
-
-    await gateway.send(msg);
-
-    expect(transport.sent).toHaveLength(1);
-    expect(transport.sent[0].to).toEqual([{ address: "user@external.org" }]);
-    expect(transport.sent[0].from).toEqual({ address: "alice@example.com" });
-    expect(storage.getMessage("M1")!.recipients[0].delivered_at).toBeTruthy();
-    expect(sent).toHaveLength(1);
-    // Outbound Message-ID recorded for later correlation.
-    expect(storage.getMessageIdByExternalId("<M1@example.com>")).toBe("M1");
-  });
-
-  it("queues a transient failure and delivers it on retry", async () => {
-    const { gateway, storage, transport, events } = setup();
-    await transport.start();
-    const queued = capture(events, "mail.queued");
-    const msg = outboundMessage();
-    storage.putMessage(msg);
-
-    transport.programNextSend({ disposition: "transient", code: 451 });
-    await gateway.send(msg);
-
-    expect(transport.sent).toHaveLength(0);
-    expect(gateway.queue.size("mail")).toBe(1);
-    expect(queued).toHaveLength(1);
-
-    // Retry — default outcome is delivered.
-    await gateway.processRetries();
-    expect(transport.sent).toHaveLength(1);
-    expect(gateway.queue.size("mail")).toBe(0);
-  });
-
-  it("bounces a permanent failure and synthesizes an inbox notice", async () => {
-    const { gateway, storage, events, transport } = setup();
-    await transport.start();
-    const bounced = capture(events, "mail.bounced");
-    const msg = outboundMessage();
-    storage.putMessage(msg);
-
-    transport.programNextSend({
-      disposition: "permanent",
-      code: 550,
-      detail: "no such user",
-    });
-
-    await gateway.send(msg);
-
-    expect(bounced).toEqual([
-      expect.objectContaining({ messageId: "M1", recipient: "user@external.org" }),
-    ]);
-    // A bounce notice landed in alice's inbox.
-    const aliceInbox = storage.getInbox("alice");
-    const notice = aliceInbox.find((m) => m.sender_id === "mailer-daemon");
-    expect(notice).toBeTruthy();
-    expect(notice!.importance).toBe("high");
-    expect(notice!.in_reply_to).toBe("M1");
-  });
-
-  it("respects config-gated bounce suppression", async () => {
-    const { gateway, storage, events, transport } = setup({
-      bounce: { emitEvent: false, synthesizeInboxMessage: false },
-    });
-    await transport.start();
-    const bounced = capture(events, "mail.bounced");
-    const msg = outboundMessage();
-    storage.putMessage(msg);
-
-    transport.programNextSend({ disposition: "permanent", code: 550 });
-    await gateway.send(msg);
-
-    expect(bounced).toHaveLength(0);
-    expect(storage.getInbox("alice")).toHaveLength(0);
-  });
-});
-
-describe("MailGateway inbound DSN", () => {
-  it("correlates an inbound bounce to the original message and notifies the sender", async () => {
-    const { gateway, storage, events } = setup();
-    const bounced = capture(events, "mail.bounced");
-
-    // Simulate a prior send: original message + recorded RFC id.
-    const original = outboundMessage({ id: "ORIG" });
-    storage.putMessage(original);
-    storage.recordExternalId("<ORIG@example.com>", "ORIG");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        from: { address: "mailer-daemon@external.org" },
-        to: [{ address: "alice@example.com" }],
-        bounce: {
-          action: "failed",
-          recipient: "user@external.org",
-          status: "5.1.1",
-          originalMessageId: "<ORIG@example.com>",
-        },
-      })
-    );
-
-    expect(bounced).toEqual([
-      expect.objectContaining({ messageId: "ORIG", status: "5.1.1" }),
-    ]);
-    const notice = storage
-      .getInbox("alice")
-      .find((m) => m.sender_id === "mailer-daemon");
-    expect(notice).toBeTruthy();
-  });
-
-  it("treats a delayed DSN as queued, not bounced", async () => {
-    const { gateway, storage, events } = setup();
-    const bounced = capture(events, "mail.bounced");
-    const queued = capture(events, "mail.queued");
-
-    const original = outboundMessage({ id: "ORIG2" });
-    storage.putMessage(original);
-    storage.recordExternalId("<ORIG2@example.com>", "ORIG2");
-
-    await gateway.handleInbound(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        bounce: {
-          action: "delayed",
-          recipient: "user@external.org",
-          originalMessageId: "<ORIG2@example.com>",
-        },
-      })
-    );
-
-    expect(bounced).toHaveLength(0);
-    expect(queued).toEqual([
-      expect.objectContaining({ messageId: "ORIG2", delayed: true }),
-    ]);
-  });
-
-  it("dedups a replayed bounce — no repeated event or inbox notice (flood guard)", async () => {
-    const { gateway, storage, events } = setup();
-    const bounced = capture(events, "mail.bounced");
-
-    const original = outboundMessage({ id: "ORIG3" });
-    storage.putMessage(original);
-    storage.recordExternalId("<ORIG3@example.com>", "ORIG3");
-
-    const dsn = () =>
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        bounce: {
-          action: "failed",
-          recipient: "user@external.org",
-          status: "5.1.1",
-          originalMessageId: "<ORIG3@example.com>",
-        },
-      });
-
-    await gateway.handleInbound(dsn());
-    await gateway.handleInbound(dsn()); // replay
-    await gateway.handleInbound(dsn()); // replay
-
-    expect(bounced).toHaveLength(1);
-    const notices = storage
-      .getInbox("alice")
-      .filter((m) => m.sender_id === "mailer-daemon");
-    expect(notices).toHaveLength(1);
-  });
-});
-
-describe("MailGateway durable retry exhaustion", () => {
-  it("bounces instead of silently dropping when retryMaxAttempts is exhausted", async () => {
-    const { gateway, storage, events, transport } = setup({
-      queue: { retryMaxAttempts: 1 },
-    });
-    await transport.start();
-    const bounced = capture(events, "mail.bounced");
-    const msg = outboundMessage();
-    storage.putMessage(msg);
-
-    // Initial send fails transiently → queued (attempt 0).
-    transport.programNextSend({ disposition: "transient", code: 451 });
-    await gateway.send(msg);
-    expect(gateway.queue.size("mail")).toBe(1);
-
-    // Retry also fails transiently → attempts hit the cap → bounce, not drop.
-    transport.programNextSend({ disposition: "transient", code: 451 });
-    await gateway.processRetries();
-
-    expect(gateway.queue.size("mail")).toBe(0);
-    expect(bounced).toHaveLength(1);
-    const notice = storage
-      .getInbox("alice")
-      .find((m) => m.sender_id === "mailer-daemon");
-    expect(notice).toBeTruthy();
-  });
-});