agent-inbox 0.2.4 → 0.2.5

package/test/mail/email-mapper.test.ts

@@ -1,341 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { AddressBook } from "../../src/mail/address-book.js";
-import {
-  inboundMailToMessage,
-  messageToOutboundMail,
-  UnknownRecipientError,
-  type InboundMapContext,
-  type OutboundMapContext,
-} from "../../src/mail/email-mapper.js";
-import { makeInboundMail } from "./mock-mail.js";
-import type { Message } from "../../src/types.js";
-
-function addressBook(): AddressBook {
-  return new AddressBook({
-    localDomains: ["example.com"],
-    mappings: [
-      { agentId: "alice", address: "alice@example.com" },
-      { agentId: "bob", address: "bob@example.com" },
-    ],
-  });
-}
-
-function inCtx(over: Partial<InboundMapContext> = {}): InboundMapContext {
-  return { addressBook: addressBook(), defaultScope: "default", ...over };
-}
-
-function outCtx(over: Partial<OutboundMapContext> = {}): OutboundMapContext {
-  return { addressBook: addressBook(), ...over };
-}
-
-describe("inboundMailToMessage", () => {
-  it("maps a basic inbound email to a Message", () => {
-    const msg = inboundMailToMessage(
-      makeInboundMail({
-        from: { address: "ext@other.org", name: "Ext" },
-        to: [{ address: "alice@example.com" }],
-        subject: "hi",
-        text: "body text",
-        headers: { messageId: "<abc@other.org>", raw: {} },
-      }),
-      inCtx()
-    );
-    expect(msg.sender_id).toBe("ext@other.org");
-    expect(msg.recipients).toEqual([{ agent_id: "alice", kind: "to" }]);
-    expect(msg.subject).toBe("hi");
-    expect(msg.content).toEqual({ type: "text", text: "body text" });
-    expect(msg.metadata.rfcMessageId).toBe("<abc@other.org>");
-    expect(msg.metadata.envelopeFrom).toBe("ext@example.org");
-  });
-
-  it("resolves cc recipients and preserves kind", () => {
-    const msg = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        cc: [{ address: "bob@example.com" }],
-      }),
-      inCtx()
-    );
-    expect(msg.recipients).toContainEqual({ agent_id: "alice", kind: "to" });
-    expect(msg.recipients).toContainEqual({ agent_id: "bob", kind: "cc" });
-  });
-
-  it("derives scope from plus-addressing on the matched to recipient", () => {
-    const msg = inboundMailToMessage(
-      makeInboundMail({ to: [{ address: "alice+project-x@example.com" }] }),
-      inCtx()
-    );
-    expect(msg.scope).toBe("project-x");
-    expect(msg.recipients[0].agent_id).toBe("alice");
-  });
-
-  it("skips unresolvable recipients but keeps resolvable ones", () => {
-    const msg = inboundMailToMessage(
-      makeInboundMail({
-        to: [
-          { address: "alice@example.com" },
-          { address: "stranger@elsewhere.net" },
-        ],
-      }),
-      inCtx()
-    );
-    expect(msg.recipients).toEqual([{ agent_id: "alice", kind: "to" }]);
-  });
-
-  it("throws UnknownRecipientError when nothing resolves", () => {
-    expect(() =>
-      inboundMailToMessage(
-        makeInboundMail({ to: [{ address: "nobody@elsewhere.net" }] }),
-        inCtx()
-      )
-    ).toThrow(UnknownRecipientError);
-  });
-
-  it("uses catch-all when configured and mailbox is unknown", () => {
-    const ab = new AddressBook({
-      localDomains: ["example.com"],
-      mappings: [],
-      catchAllAgentId: "triage",
-    });
-    const msg = inboundMailToMessage(
-      makeInboundMail({ to: [{ address: "whoever@example.com" }] }),
-      inCtx({ addressBook: ab })
-    );
-    expect(msg.recipients[0].agent_id).toBe("triage");
-  });
-
-  it("derives a stable thread_tag from the References root", () => {
-    const a = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        headers: {
-          messageId: "<m2@x>",
-          references: ["<root@x>", "<m1@x>"],
-          raw: {},
-        },
-      }),
-      inCtx()
-    );
-    const b = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        headers: {
-          messageId: "<m3@x>",
-          references: ["<root@x>"],
-          raw: {},
-        },
-      }),
-      inCtx()
-    );
-    expect(a.thread_tag).toBeTruthy();
-    expect(a.thread_tag).toBe(b.thread_tag); // same root → same thread
-  });
-
-  it("resolves in_reply_to to an inbox id when the RFC id is known", () => {
-    const msg = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        headers: { messageId: "<reply@x>", inReplyTo: "<parent@x>", raw: {} },
-      }),
-      inCtx({
-        lookupInboxIdByRfcMessageId: (id) =>
-          id === "<parent@x>" ? "inbox-parent-123" : undefined,
-      })
-    );
-    expect(msg.in_reply_to).toBe("inbox-parent-123");
-    expect(msg.metadata.rfcInReplyTo).toBe("<parent@x>");
-  });
-
-  it("maps X-Priority / Importance headers to importance", () => {
-    const high = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        headers: { raw: { "x-priority": "1" } },
-      }),
-      inCtx()
-    );
-    expect(high.importance).toBe("high");
-    const low = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        headers: { raw: { importance: "low" } },
-      }),
-      inCtx()
-    );
-    expect(low.importance).toBe("low");
-  });
-
-  it("retains an inbound bounce in metadata", () => {
-    const msg = inboundMailToMessage(
-      makeInboundMail({
-        to: [{ address: "alice@example.com" }],
-        bounce: {
-          action: "failed",
-          recipient: "gone@nowhere.net",
-          status: "5.1.1",
-          originalMessageId: "<orig@example.com>",
-        },
-      }),
-      inCtx()
-    );
-    expect(msg.metadata.bounce).toMatchObject({ action: "failed" });
-  });
-});
-
-describe("messageToOutboundMail", () => {
-  function baseMessage(over: Partial<Message> = {}): Message {
-    return {
-      id: "01ABCDEF",
-      scope: "default",
-      sender_id: "alice",
-      recipients: [{ agent_id: "ext@other.org", kind: "to" }],
-      subject: "subject",
-      content: { type: "text", text: "hello world" },
-      importance: "normal",
-      metadata: {},
-      created_at: new Date().toISOString(),
-      ...over,
-    };
-  }
-
-  it("renders a Message into an OutboundMail", () => {
-    const out = messageToOutboundMail(baseMessage(), outCtx());
-    expect(out.idempotencyKey).toBe("01ABCDEF");
-    expect(out.from).toEqual({ address: "alice@example.com" });
-    expect(out.to).toEqual([{ address: "ext@other.org" }]);
-    expect(out.text).toBe("hello world");
-    expect(out.headers.messageId).toBe("<01ABCDEF@example.com>");
-  });
-
-  it("falls back to <agentId>@primaryDomain for an unmapped sender", () => {
-    const out = messageToOutboundMail(
-      baseMessage({ sender_id: "ghost" }),
-      outCtx()
-    );
-    expect(out.from).toEqual({ address: "ghost@example.com" });
-  });
-
-  it("splits recipients by kind into to/cc/bcc", () => {
-    const out = messageToOutboundMail(
-      baseMessage({
-        recipients: [
-          { agent_id: "a@x.org", kind: "to" },
-          { agent_id: "b@x.org", kind: "cc" },
-          { agent_id: "c@x.org", kind: "bcc" },
-        ],
-      }),
-      outCtx()
-    );
-    expect(out.to).toEqual([{ address: "a@x.org" }]);
-    expect(out.cc).toEqual([{ address: "b@x.org" }]);
-    expect(out.bcc).toEqual([{ address: "c@x.org" }]);
-  });
-
-  it("builds In-Reply-To / References from a known parent", () => {
-    const out = messageToOutboundMail(
-      baseMessage({ in_reply_to: "inbox-parent" }),
-      outCtx({
-        lookupRfcMessageId: (id) =>
-          id === "inbox-parent" ? "<parent@other.org>" : undefined,
-        lookupReferences: () => ["<root@other.org>"],
-      })
-    );
-    expect(out.headers.inReplyTo).toBe("<parent@other.org>");
-    expect(out.headers.references).toEqual([
-      "<root@other.org>",
-      "<parent@other.org>",
-    ]);
-  });
-
-  it("synthesizes a parent Message-ID when the RFC id is unknown", () => {
-    const out = messageToOutboundMail(
-      baseMessage({ in_reply_to: "inbox-parent" }),
-      outCtx()
-    );
-    expect(out.headers.inReplyTo).toBe("<inbox-parent@example.com>");
-  });
-
-  it("carries html body from metadata but does NOT leak arbitrary metadata to the backend", () => {
-    const out = messageToOutboundMail(
-      baseMessage({
-        metadata: { htmlBody: "<p>hi</p>", rfcMessageId: "<x@y>", userTag: "internal" },
-      }),
-      outCtx()
-    );
-    expect(out.html).toBe("<p>hi</p>");
-    // Internal metadata must not be forwarded to the external mail provider.
-    expect(out.backendHints).toBeUndefined();
-  });
-
-  it("forwards only an explicit mailBackendHints object to the backend", () => {
-    const out = messageToOutboundMail(
-      baseMessage({
-        metadata: { secret: "no", mailBackendHints: { tag: "newsletter" } },
-      }),
-      outCtx()
-    );
-    expect(out.backendHints).toEqual({ tag: "newsletter" });
-  });
-
-  it("validates and filters malformed attachment metadata", () => {
-    const out = messageToOutboundMail(
-      baseMessage({
-        metadata: {
-          mailAttachments: [
-            { contentRef: "sha256:a", contentType: "text/plain", sizeBytes: 3, filename: "ok.txt" },
-            { bogus: true }, // dropped — missing contentRef/contentType
-            "not-an-object", // dropped
-          ],
-        },
-      }),
-      outCtx()
-    );
-    expect(out.attachments).toEqual([
-      { contentRef: "sha256:a", contentType: "text/plain", sizeBytes: 3, filename: "ok.txt" },
-    ]);
-  });
-});
-
-describe("round-trip", () => {
-  it("preserves subject, body, and threading across inbound→outbound reply", () => {
-    const ab = addressBook();
-    // Inbound arrives for alice.
-    const inbound = inboundMailToMessage(
-      makeInboundMail({
-        from: { address: "ext@other.org" },
-        to: [{ address: "alice@example.com" }],
-        subject: "Question",
-        text: "what is the status?",
-        headers: { messageId: "<q1@other.org>", raw: {} },
-      }),
-      { addressBook: ab }
-    );
-
-    // Alice replies: a new message in_reply_to the inbound one, to the sender.
-    const reply: Message = {
-      id: "REPLY1",
-      scope: inbound.scope,
-      sender_id: "alice",
-      recipients: [{ agent_id: "ext@other.org", kind: "to" }],
-      subject: "Re: Question",
-      content: { type: "text", text: "all good" },
-      in_reply_to: inbound.id,
-      importance: "normal",
-      metadata: {},
-      created_at: new Date().toISOString(),
-    };
-
-    const out = messageToOutboundMail(reply, {
-      addressBook: ab,
-      // The reply's parent is the inbound message; its recorded RFC id:
-      lookupRfcMessageId: (id) =>
-        id === inbound.id ? (inbound.metadata.rfcMessageId as string) : undefined,
-    });
-
-    expect(out.to).toEqual([{ address: "ext@other.org" }]);
-    expect(out.subject).toBe("Re: Question");
-    expect(out.text).toBe("all good");
-    expect(out.headers.inReplyTo).toBe("<q1@other.org>");
-    expect(out.headers.references).toEqual(["<q1@other.org>"]);
-  });
-});

package/test/mail/external-id.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import Database from "better-sqlite3";
-import { InMemoryStorage } from "../../src/storage/memory.js";
-import { SqliteStorage } from "../../src/storage/sqlite.js";
-import type { Storage } from "../../src/storage/interface.js";
-
-const dbs: Database.Database[] = [];
-afterEach(() => {
-  while (dbs.length) dbs.pop()!.close();
-});
-
-function sqlite(): Storage {
-  const db = new Database(":memory:");
-  dbs.push(db);
-  return new SqliteStorage({ db });
-}
-
-const impls: Array<[string, () => Storage]> = [
-  ["InMemoryStorage", () => new InMemoryStorage()],
-  ["SqliteStorage", () => sqlite()],
-];
-
-describe.each(impls)("external-id mapping (%s)", (_name, make) => {
-  it("records and looks up an external id", () => {
-    const s = make();
-    s.recordExternalId("<abc@x>", "msg-1");
-    expect(s.getMessageIdByExternalId("<abc@x>")).toBe("msg-1");
-    expect(s.hasSeenExternalId("<abc@x>")).toBe(true);
-  });
-
-  it("reports unseen ids", () => {
-    const s = make();
-    expect(s.hasSeenExternalId("<nope@x>")).toBe(false);
-    expect(s.getMessageIdByExternalId("<nope@x>")).toBeUndefined();
-  });
-
-  it("is idempotent: first mapping wins", () => {
-    const s = make();
-    s.recordExternalId("<dup@x>", "msg-1");
-    s.recordExternalId("<dup@x>", "msg-2");
-    expect(s.getMessageIdByExternalId("<dup@x>")).toBe("msg-1");
-  });
-});

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

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