agent-inbox 0.2.2 → 0.2.4

package/test/mail/fs-attachment-store.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { FsAttachmentStore } from "../../src/mail/fs-attachment-store.js";
+
+describe("FsAttachmentStore", () => {
+  let dir: string;
+  let store: FsAttachmentStore;
+
+  beforeEach(async () => {
+    dir = await fs.mkdtemp(path.join(os.tmpdir(), "att-"));
+    store = new FsAttachmentStore(dir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(dir, { recursive: true, force: true });
+  });
+
+  it("stores and retrieves bytes by ref", async () => {
+    const bytes = Buffer.from("hello filesystem attachment");
+    const ref = await store.put(bytes, { contentType: "text/plain" });
+    const got = await store.get(ref);
+    expect(got.equals(bytes)).toBe(true);
+  });
+
+  it("produces content-addressed (sha256:) refs", async () => {
+    const ref = await store.put(Buffer.from("x"), { contentType: "text/plain" });
+    expect(ref).toMatch(/^sha256:[0-9a-f]{64}$/);
+  });
+
+  it("dedups identical bytes to the same ref and a single file", async () => {
+    const a = await store.put(Buffer.from("same"), { contentType: "text/plain" });
+    const b = await store.put(Buffer.from("same"), { contentType: "text/plain" });
+    expect(a).toBe(b);
+    // One shard dir, one file in it.
+    const shards = await fs.readdir(dir);
+    expect(shards).toHaveLength(1);
+    const files = await fs.readdir(path.join(dir, shards[0]));
+    expect(files.filter((f) => !f.includes(".tmp-"))).toHaveLength(1);
+  });
+
+  it("gives different refs for different bytes", async () => {
+    const a = await store.put(Buffer.from("one"), { contentType: "text/plain" });
+    const b = await store.put(Buffer.from("two"), { contentType: "text/plain" });
+    expect(a).not.toBe(b);
+  });
+
+  it("shards files by the first byte of the hash", async () => {
+    const bytes = Buffer.from("shard me");
+    const ref = await store.put(bytes, { contentType: "text/plain" });
+    const hex = ref.slice("sha256:".length);
+    const expected = path.join(dir, hex.slice(0, 2), hex);
+    await expect(fs.access(expected)).resolves.toBeUndefined();
+  });
+
+  it("deletes by ref", async () => {
+    const ref = await store.put(Buffer.from("gone"), { contentType: "text/plain" });
+    await store.delete(ref);
+    await expect(store.get(ref)).rejects.toThrow(/not found/);
+  });
+
+  it("delete is a no-op for a missing ref", async () => {
+    const ref = "sha256:" + "a".repeat(64);
+    await expect(store.delete(ref)).resolves.toBeUndefined();
+  });
+
+  it("throws a clear error on a missing ref", async () => {
+    await expect(store.get("sha256:" + "b".repeat(64))).rejects.toThrow(/not found/);
+  });
+
+  it("rejects malformed / path-traversal refs", async () => {
+    await expect(store.get("sha256:../../etc/passwd")).rejects.toThrow(/Invalid attachment ref/);
+    await expect(store.get("../../etc/passwd")).rejects.toThrow(/Invalid attachment ref/);
+    await expect(store.delete("sha256:..")).rejects.toThrow(/Invalid attachment ref/);
+    await expect(store.get("sha256:ABC")).rejects.toThrow(/Invalid attachment ref/);
+  });
+
+  it("persists across store instances over the same directory", async () => {
+    const ref = await store.put(Buffer.from("durable"), { contentType: "text/plain" });
+    const reopened = new FsAttachmentStore(dir);
+    const got = await reopened.get(ref);
+    expect(got.toString()).toBe("durable");
+  });
+
+  it("handles concurrent puts of identical bytes without corruption", async () => {
+    const bytes = Buffer.from("racy-content");
+    const refs = await Promise.all(
+      Array.from({ length: 8 }, () => store.put(bytes, { contentType: "text/plain" }))
+    );
+    expect(new Set(refs).size).toBe(1);
+    expect((await store.get(refs[0])).equals(bytes)).toBe(true);
+  });
+
+  it("round-trips binary content exactly", async () => {
+    const bytes = Buffer.from([0x00, 0xff, 0x10, 0x7f, 0x80, 0x00, 0x01]);
+    const ref = await store.put(bytes, { contentType: "application/octet-stream" });
+    expect((await store.get(ref)).equals(bytes)).toBe(true);
+  });
+
+  describe("gc", () => {
+    it("removes orphan files not in the live set", async () => {
+      const keep = await store.put(Buffer.from("keep"), { contentType: "text/plain" });
+      const drop = await store.put(Buffer.from("drop"), { contentType: "text/plain" });
+
+      // minAgeMs: 0 so just-written files are eligible (the default 1h grace
+      // period protects in-flight attachments from a concurrent gc).
+      const removed = await store.gc(new Set([keep]), 0);
+      expect(removed).toBe(1);
+      await expect(store.get(keep)).resolves.toBeTruthy();
+      await expect(store.get(drop)).rejects.toThrow(/not found/);
+    });
+
+    it("does not delete recently-written orphans within the grace period", async () => {
+      const drop = await store.put(Buffer.from("fresh-orphan"), { contentType: "text/plain" });
+      // Default grace period (1h) — the just-written file is too new to GC.
+      const removed = await store.gc(new Set());
+      expect(removed).toBe(0);
+      await expect(store.get(drop)).resolves.toBeTruthy();
+    });
+
+    it("ignores stray non-directory entries at the root", async () => {
+      await store.put(Buffer.from("real"), { contentType: "text/plain" });
+      await fs.writeFile(path.join(dir, "stray.txt"), "junk");
+      // Should not throw on the stray file.
+      await expect(store.gc(new Set(), 0)).resolves.toBeTypeOf("number");
+    });
+
+    it("returns 0 when the directory does not exist yet", async () => {
+      const fresh = new FsAttachmentStore(path.join(dir, "does-not-exist"));
+      expect(await fresh.gc(new Set())).toBe(0);
+    });
+  });
+});

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

@@ -0,0 +1,200 @@
+/**
+ * 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);
+  });
+});