agent-inbox 0.2.4 → 0.2.5

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

@@ -1,92 +0,0 @@
-/**
- * Shared AttachmentStore contract — both backends (SQLite BLOB + filesystem)
- * must satisfy the same behavior, so they are interchangeable behind the
- * opaque `contentRef`. Mirrors the mail-transport contract pattern.
- */
-
-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 Database from "better-sqlite3";
-import type { AttachmentStore } from "../../src/mail/types.js";
-import { SqliteAttachmentStore } from "../../src/mail/attachment-store.js";
-import { FsAttachmentStore } from "../../src/mail/fs-attachment-store.js";
-
-interface Harness {
-  store: AttachmentStore;
-  cleanup: () => Promise<void> | void;
-}
-
-function runAttachmentStoreContract(
-  name: string,
-  makeHarness: () => Promise<Harness>
-): void {
-  describe(`AttachmentStore contract: ${name}`, () => {
-    let h: Harness;
-    beforeEach(async () => {
-      h = await makeHarness();
-    });
-    afterEach(async () => {
-      await h.cleanup();
-    });
-
-    it("round-trips stored bytes by ref", async () => {
-      const bytes = Buffer.from("contract bytes");
-      const ref = await h.store.put(bytes, { contentType: "text/plain" });
-      expect((await h.store.get(ref)).equals(bytes)).toBe(true);
-    });
-
-    it("produces sha256-based content-addressed refs", async () => {
-      const ref = await h.store.put(Buffer.from("x"), { contentType: "text/plain" });
-      expect(ref).toMatch(/^sha256:[0-9a-f]{64}$/);
-    });
-
-    it("dedups identical bytes to the same ref", async () => {
-      const a = await h.store.put(Buffer.from("same"), { contentType: "text/plain" });
-      const b = await h.store.put(Buffer.from("same"), { contentType: "text/plain" });
-      expect(a).toBe(b);
-    });
-
-    it("gives different refs for different bytes", async () => {
-      const a = await h.store.put(Buffer.from("one"), { contentType: "text/plain" });
-      const b = await h.store.put(Buffer.from("two"), { contentType: "text/plain" });
-      expect(a).not.toBe(b);
-    });
-
-    it("throws on a missing ref", async () => {
-      await expect(h.store.get("sha256:" + "a".repeat(64))).rejects.toThrow(/not found/);
-    });
-
-    it("rejects a malformed ref on get and delete (both backends)", async () => {
-      await expect(h.store.get("garbage")).rejects.toThrow(/Invalid attachment ref/);
-      await expect(h.store.get("sha256:../../etc/passwd")).rejects.toThrow(/Invalid attachment ref/);
-      await expect(h.store.delete("sha256:short")).rejects.toThrow(/Invalid attachment ref/);
-    });
-
-    it("deletes by ref", async () => {
-      const ref = await h.store.put(Buffer.from("gone"), { contentType: "text/plain" });
-      await h.store.delete(ref);
-      await expect(h.store.get(ref)).rejects.toThrow(/not found/);
-    });
-
-    it("round-trips arbitrary binary content exactly", async () => {
-      const bytes = Buffer.from([0x00, 0xff, 0x7f, 0x80, 0x01, 0x00]);
-      const ref = await h.store.put(bytes, { contentType: "application/octet-stream" });
-      expect((await h.store.get(ref)).equals(bytes)).toBe(true);
-    });
-  });
-}
-
-runAttachmentStoreContract("SqliteAttachmentStore", async () => {
-  const db = new Database(":memory:");
-  return { store: new SqliteAttachmentStore(db), cleanup: () => db.close() };
-});
-
-runAttachmentStoreContract("FsAttachmentStore", async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "att-contract-"));
-  return {
-    store: new FsAttachmentStore(dir),
-    cleanup: () => fs.rm(dir, { recursive: true, force: true }),
-  };
-});

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

@@ -1,69 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Database from "better-sqlite3";
-import { SqliteAttachmentStore } from "../../src/mail/attachment-store.js";
-
-describe("SqliteAttachmentStore", () => {
-  let db: Database.Database;
-  let store: SqliteAttachmentStore;
-
-  beforeEach(() => {
-    db = new Database(":memory:");
-    store = new SqliteAttachmentStore(db);
-  });
-
-  afterEach(() => db.close());
-
-  it("stores and retrieves bytes by ref", async () => {
-    const bytes = Buffer.from("hello 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 single row", 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);
-    const count = db
-      .prepare("SELECT COUNT(*) AS n FROM mail_attachments")
-      .get() as { n: number };
-    expect(count.n).toBe(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("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("throws on missing ref", async () => {
-    await expect(store.get("sha256:" + "0".repeat(64))).rejects.toThrow(/not found/);
-  });
-
-  it("persists filename and size metadata", async () => {
-    const bytes = Buffer.from("with-meta");
-    const ref = await store.put(bytes, {
-      contentType: "application/pdf",
-      filename: "doc.pdf",
-    });
-    const row = db
-      .prepare(
-        "SELECT content_type, filename, size_bytes FROM mail_attachments WHERE ref = ?"
-      )
-      .get(ref) as { content_type: string; filename: string; size_bytes: number };
-    expect(row.content_type).toBe("application/pdf");
-    expect(row.filename).toBe("doc.pdf");
-    expect(row.size_bytes).toBe(bytes.length);
-  });
-});

package/test/mail/destination.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  classifyDestination,
-  findDomainConflicts,
-  UnknownDestinationError,
-  type DestinationContext,
-} from "../../src/router/destination.js";
-
-function ctx(overrides: Partial<DestinationContext> = {}): DestinationContext {
-  return {
-    isLocalAgent: (id) => ["alice", "bob"].includes(id),
-    federationPeers: [{ systemId: "system-2" }],
-    mailDomains: ["example.com"],
-    ...overrides,
-  };
-}
-
-describe("classifyDestination", () => {
-  it("classifies a bare id as local", () => {
-    expect(classifyDestination("alice", ctx())).toEqual({
-      class: "local",
-      agentId: "alice",
-    });
-  });
-
-  it("classifies an unknown bare id as local (no domain to disambiguate)", () => {
-    // No @ means there is no domain to route on — it is a local-namespace id.
-    expect(classifyDestination("charlie", ctx())).toEqual({
-      class: "local",
-      agentId: "charlie",
-    });
-  });
-
-  it("classifies a configured federation peer system as federation", () => {
-    const d = classifyDestination("bob@system-2", ctx());
-    expect(d.class).toBe("federation");
-    if (d.class === "federation") {
-      expect(d.address).toEqual({ agent: "bob", system: "system-2" });
-    }
-  });
-
-  it("classifies a configured mail domain as mail", () => {
-    expect(classifyDestination("bob@example.com", ctx())).toEqual({
-      class: "mail",
-      email: "bob@example.com",
-    });
-  });
-
-  it("matches subdomains of a configured mail domain", () => {
-    expect(classifyDestination("bob@mail.example.com", ctx())).toEqual({
-      class: "mail",
-      email: "bob@mail.example.com",
-    });
-  });
-
-  it("does not match a domain that merely shares a suffix string", () => {
-    // notexample.com must NOT match example.com
-    expect(() => classifyDestination("bob@notexample.com", ctx())).toThrow(
-      UnknownDestinationError
-    );
-  });
-
-  it("throws UnknownDestinationError for an unlisted domain", () => {
-    expect(() => classifyDestination("bob@gmail.com", ctx())).toThrow(
-      UnknownDestinationError
-    );
-  });
-
-  it("lets a federation peer's declared domain win over mail config", () => {
-    // corp.internal is claimed by BOTH a peer and mail config — federation wins.
-    const c = ctx({
-      federationPeers: [{ systemId: "system-2", domains: ["corp.internal"] }],
-      mailDomains: ["example.com", "corp.internal"],
-    });
-    const d = classifyDestination("team@corp.internal", c);
-    expect(d.class).toBe("federation");
-  });
-
-  it("routes a dotted federation domain that is not in mail config", () => {
-    const c = ctx({
-      federationPeers: [{ systemId: "hub", domains: ["team.corp.internal"] }],
-      mailDomains: ["example.com"],
-    });
-    expect(classifyDestination("svc@team.corp.internal", c).class).toBe(
-      "federation"
-    );
-  });
-
-  it("strips a trailing /scope from a mail address", () => {
-    expect(classifyDestination("bob@example.com/work", ctx())).toEqual({
-      class: "mail",
-      email: "bob@example.com",
-    });
-  });
-
-  it("is case-insensitive on domain matching", () => {
-    expect(classifyDestination("bob@Example.COM", ctx()).class).toBe("mail");
-  });
-});
-
-describe("findDomainConflicts", () => {
-  it("reports domains claimed by both a peer and mail config", () => {
-    const conflicts = findDomainConflicts(
-      ctx({
-        federationPeers: [{ systemId: "s", domains: ["corp.internal", "ok.net"] }],
-        mailDomains: ["example.com", "corp.internal"],
-      })
-    );
-    expect(conflicts).toEqual(["corp.internal"]);
-  });
-
-  it("returns empty when there is no overlap", () => {
-    expect(findDomainConflicts(ctx())).toEqual([]);
-  });
-});

package/test/mail/dsn-parse.test.ts

@@ -1,239 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseDsnFromParsed, parsedToInboundMail } from "../../src/mail/smtp-transport.js";
-
-// Build a mailparser-like object with a delivery-status part and (optionally) a
-// returned message/rfc822 part.
-function dsnParsed(opts: {
-  contentType?: string;
-  statusText: string;
-  originalRfc822?: string;
-}) {
-  const attachments = [
-    {
-      content: Buffer.from(opts.statusText),
-      contentType: "message/delivery-status",
-      size: opts.statusText.length,
-    },
-  ];
-  if (opts.originalRfc822) {
-    attachments.push({
-      content: Buffer.from(opts.originalRfc822),
-      contentType: "message/rfc822",
-      size: opts.originalRfc822.length,
-    });
-  }
-  return {
-    headers: new Map<string, unknown>([
-      [
-        "content-type",
-        opts.contentType ?? "multipart/report; report-type=delivery-status",
-      ],
-    ]),
-    attachments,
-  };
-}
-
-describe("parseDsnFromParsed", () => {
-  it("returns undefined for ordinary mail", () => {
-    expect(
-      parseDsnFromParsed({ subject: "hello", text: "hi", attachments: [] })
-    ).toBeUndefined();
-  });
-
-  it("parses a hard-failure DSN", () => {
-    const dsn = parseDsnFromParsed(
-      dsnParsed({
-        statusText:
-          "Reporting-MTA: dns; mail.example.com\r\n" +
-          "Final-Recipient: rfc822; gone@nowhere.example\r\n" +
-          "Action: failed\r\n" +
-          "Status: 5.1.1\r\n" +
-          "Diagnostic-Code: smtp; 550 5.1.1 No such user\r\n",
-        originalRfc822: "Message-ID: <orig-123@example.com>\r\nSubject: hi\r\n",
-      })
-    );
-    expect(dsn).toEqual({
-      action: "failed",
-      recipient: "gone@nowhere.example",
-      status: "5.1.1",
-      originalMessageId: "<orig-123@example.com>",
-      diagnostic: "smtp; 550 5.1.1 No such user",
-    });
-  });
-
-  it("classifies a 4.x.x status as delayed even without Action", () => {
-    const dsn = parseDsnFromParsed(
-      dsnParsed({
-        statusText:
-          "Final-Recipient: rfc822; slow@example.com\r\nStatus: 4.4.1\r\n",
-      })
-    );
-    expect(dsn?.action).toBe("delayed");
-  });
-
-  it("honors Action: delayed", () => {
-    const dsn = parseDsnFromParsed(
-      dsnParsed({
-        statusText:
-          "Final-Recipient: rfc822; slow@example.com\r\nAction: delayed\r\nStatus: 4.2.2\r\n",
-      })
-    );
-    expect(dsn?.action).toBe("delayed");
-  });
-
-  it("maps a positive (relayed/delivered) DSN to delivered", () => {
-    const dsn = parseDsnFromParsed(
-      dsnParsed({
-        statusText:
-          "Final-Recipient: rfc822; ok@example.com\r\nAction: relayed\r\nStatus: 2.0.0\r\n",
-      })
-    );
-    expect(dsn?.action).toBe("delivered");
-  });
-
-  it("falls back to Original-Recipient when Final-Recipient is absent", () => {
-    const dsn = parseDsnFromParsed(
-      dsnParsed({
-        statusText:
-          "Original-Recipient: rfc822; orig@example.com\r\nAction: failed\r\nStatus: 5.0.0\r\n",
-      })
-    );
-    expect(dsn?.recipient).toBe("orig@example.com");
-  });
-
-  it("does NOT classify an ordinary message that merely carries an attached DSN", () => {
-    // Top-level content-type is not multipart/report (e.g. a user forwarding a
-    // bounce to support). Detecting on the attachment alone would misroute it.
-    const dsn = parseDsnFromParsed(
-      dsnParsed({
-        contentType: "multipart/mixed; boundary=x",
-        statusText: "Final-Recipient: rfc822; x@y.com\r\nAction: failed\r\nStatus: 5.0.0\r\n",
-      })
-    );
-    expect(dsn).toBeUndefined();
-  });
-
-  it("returns undefined for a multipart/report with no delivery-status part", () => {
-    expect(
-      parseDsnFromParsed({
-        headers: new Map([["content-type", "multipart/report; report-type=delivery-status"]]),
-        attachments: [],
-      })
-    ).toBeUndefined();
-  });
-
-  it("flows through parsedToInboundMail into the bounce field", () => {
-    const mail = parsedToInboundMail(
-      dsnParsed({
-        statusText:
-          "Final-Recipient: rfc822; gone@x.com\r\nAction: failed\r\nStatus: 5.1.1\r\n",
-      }),
-      { envelopeFrom: "mailer-daemon@mta", envelopeTo: [], sizeBytes: 100 }
-    );
-    expect(mail.bounce).toMatchObject({ action: "failed", recipient: "gone@x.com" });
-  });
-});
-
-// Integration: parse a realistic DSN with the REAL mailparser, since synthetic
-// fixtures above don't match how mailparser surfaces a multipart/report (it
-// folds the delivery-status block into `text`, not `attachments`, when there is
-// no Content-Disposition). This guards against the regression where real
-// Postfix/Gmail bounces were silently dropped.
-const haveMailparser = await import("mailparser")
-  .then(() => true)
-  .catch(() => false);
-
-describe.skipIf(!haveMailparser)("parseDsnFromParsed (real mailparser)", () => {
-  // A Postfix-style hard bounce: multipart/report, delivery-status part has NO
-  // Content-Disposition, plus a text/rfc822-headers part with the original id.
-  const RAW_HARD_BOUNCE = [
-    "From: MAILER-DAEMON@mail.example.com",
-    "To: alice@example.com",
-    "Subject: Undelivered Mail Returned to Sender",
-    "MIME-Version: 1.0",
-    'Content-Type: multipart/report; report-type=delivery-status; boundary="BOUND"',
-    "",
-    "--BOUND",
-    "Content-Type: text/plain; charset=us-ascii",
-    "",
-    "This is the mail system at host mail.example.com.",
-    "Your message could not be delivered.",
-    "",
-    "--BOUND",
-    "Content-Type: message/delivery-status",
-    "",
-    "Reporting-MTA: dns; mail.example.com",
-    "",
-    "Final-Recipient: rfc822; gone@nowhere.example",
-    "Action: failed",
-    "Status: 5.1.1",
-    "Diagnostic-Code: smtp; 550 5.1.1 <gone@nowhere.example>: User unknown",
-    "",
-    "--BOUND",
-    "Content-Type: text/rfc822-headers",
-    "",
-    "Message-ID: <orig-abc@example.com>",
-    "Subject: hi there",
-    "",
-    "--BOUND--",
-    "",
-  ].join("\r\n");
-
-  async function parse(raw: string) {
-    const { simpleParser } = await import("mailparser");
-    return simpleParser(Buffer.from(raw));
-  }
-
-  it("detects a real Postfix-style hard bounce folded into the text body", async () => {
-    const parsed = await parse(RAW_HARD_BOUNCE);
-    const dsn = parseDsnFromParsed(parsed as never);
-    expect(dsn).toBeTruthy();
-    expect(dsn!.action).toBe("failed");
-    expect(dsn!.recipient).toBe("gone@nowhere.example");
-    expect(dsn!.status).toBe("5.1.1");
-    expect(dsn!.originalMessageId).toBe("<orig-abc@example.com>");
-    expect(dsn!.diagnostic).toMatch(/User unknown/);
-  });
-
-  it("classifies a real 4.x.x soft bounce as delayed", async () => {
-    const soft = RAW_HARD_BOUNCE.replace("Action: failed", "Action: delayed").replace(
-      "Status: 5.1.1",
-      "Status: 4.4.1"
-    );
-    const dsn = parseDsnFromParsed((await parse(soft)) as never);
-    expect(dsn?.action).toBe("delayed");
-  });
-
-  it("does not classify an ordinary multipart/mixed email as a bounce", async () => {
-    const ordinary = [
-      "From: bob@example.com",
-      "To: alice@example.com",
-      "Subject: hi",
-      "MIME-Version: 1.0",
-      'Content-Type: multipart/mixed; boundary="B"',
-      "",
-      "--B",
-      "Content-Type: text/plain",
-      "",
-      "just a normal message",
-      "--B--",
-      "",
-    ].join("\r\n");
-    const dsn = parseDsnFromParsed((await parse(ordinary)) as never);
-    expect(dsn).toBeUndefined();
-  });
-
-  it("flows a real bounce through parsedToInboundMail into the bounce field", async () => {
-    const parsed = await parse(RAW_HARD_BOUNCE);
-    const mail = parsedToInboundMail(parsed as never, {
-      envelopeFrom: "MAILER-DAEMON@mail.example.com",
-      envelopeTo: ["alice@example.com"],
-      sizeBytes: RAW_HARD_BOUNCE.length,
-    });
-    expect(mail.bounce).toMatchObject({
-      action: "failed",
-      recipient: "gone@nowhere.example",
-      originalMessageId: "<orig-abc@example.com>",
-    });
-  });
-});