@open-workspace/email 0.0.0-stage → 0.1.1

package/worker/mail/ip-intel.ts

@@ -0,0 +1,135 @@
+import type { SenderIntel } from "../../shared/mail-sender-intel";
+import { normalizeIp } from "../../shared/mail-received";
+import type { DnsResolver } from "./doh";
+import { organizationalDomain } from "./org-domain";
+
+const MAX_CONFIRMED_PTR_NAMES = 2;
+
+export type IpIntel = Pick<SenderIntel, "ptr" | "network">;
+
+function expandIpv6(ip: string) {
+  const [head = "", tail = ""] = ip.split("::");
+  const left = head ? head.split(":") : [];
+  const right = ip.includes("::") ? (tail ? tail.split(":") : []) : [];
+  const fill = Array.from({ length: 8 - left.length - right.length }, () => "0");
+  return [...left, ...fill, ...right].map((group) => group.padStart(4, "0")).join("");
+}
+
+/** `1.2.3.4` → `4.3.2.1`; IPv6 → nibble-reversed hex, as used under in-addr.arpa / ip6.arpa. */
+export function reversedIp(ip: string) {
+  if (ip.includes(":")) return [...expandIpv6(ip)].reverse().join(".");
+  return ip.split(".").reverse().join(".");
+}
+
+export function reverseDnsName(ip: string) {
+  return `${reversedIp(ip)}.${ip.includes(":") ? "ip6.arpa" : "in-addr.arpa"}`;
+}
+
+const GENERIC_PTR_WORDS =
+  /(?:^|[.-])(?:dynamic|dyn|pool|dsl|adsl|xdsl|vdsl|dhcp|dialup|dial|ppp|pppoe|cable|broadband|customer|cust|clients|residential|cpe|fttx|ftth)(?:\d*[.-]|$)/u;
+
+/** Auto-generated access-network names such as `1-2-3-4.dsl.example.net`. */
+export function isGenericPtr(name: string, ip: string) {
+  const host = name.toLocaleLowerCase();
+  if (!ip.includes(":")) {
+    const octets = ip.split(".");
+    const forward = octets.join("[.-]");
+    const backward = [...octets].reverse().join("[.-]");
+    if (new RegExp(`(?:^|\\D)(?:${forward}|${backward})(?:\\D|$)`, "u").test(host)) return true;
+    const hex = octets.map((octet) => Number(octet).toString(16).padStart(2, "0")).join("");
+    if (host.includes(hex)) return true;
+  }
+  const firstLabels = host.split(".").slice(0, -2).join(".");
+  return GENERIC_PTR_WORDS.test(firstLabels);
+}
+
+/** `"15169 | 8.8.8.0/24 | US | arin | 1992-12-01"` (first ASN wins for multi-origin prefixes). */
+export function parseCymruOrigin(value: string) {
+  const [asns, prefix, country, registry] = value.split("|").map((part) => part.trim());
+  const asn = Number(asns?.split(/\s+/u)[0]);
+  if (!Number.isInteger(asn) || asn <= 0) return null;
+  return {
+    asn,
+    prefix: prefix || null,
+    country: country && /^[a-z]{2}$/iu.test(country) ? country.toUpperCase() : null,
+    registry: registry?.toLocaleLowerCase() || null,
+  };
+}
+
+/** `"15169 | US | arin | 2000-03-30 | GOOGLE - Google LLC, US"` → `Google LLC`. */
+export function parseCymruAsName(value: string) {
+  const raw = value.split("|").slice(4).join("|").trim();
+  if (!raw) return null;
+  const withoutCountry = raw.replace(/,\s*[A-Z]{2}$/u, "").trim();
+  const dash = withoutCountry.indexOf(" - ");
+  const name = dash >= 0 ? withoutCountry.slice(dash + 3).trim() : withoutCountry;
+  return name.slice(0, 120) || null;
+}
+
+async function ptrIntel(resolve: DnsResolver, ip: string): Promise<IpIntel["ptr"]> {
+  const answer = await resolve(reverseDnsName(ip), "PTR");
+  const names = [...new Set(answer.records)].filter(Boolean).slice(0, 5);
+  if (answer.status !== "ok" || !names.length) {
+    return {
+      status: answer.status === "ok" ? "nxdomain" : answer.status,
+      names: [],
+      confirmed: null,
+      fcrdns: answer.status === "ok" || answer.status === "nxdomain" ? false : null,
+      generic: null,
+    };
+  }
+  const forwardType = ip.includes(":") ? "AAAA" : "A";
+  const checks = await Promise.all(names.slice(0, MAX_CONFIRMED_PTR_NAMES).map(async (name) => {
+    const forward = await resolve(name, forwardType);
+    const confirmed = forward.records.some((record) => normalizeIp(record) === ip);
+    return { name, status: forward.status, confirmed };
+  }));
+  const confirmed = checks.find((check) => check.confirmed)?.name ?? null;
+  const answered = checks.some((check) => check.status === "ok" || check.status === "nxdomain");
+  return {
+    status: "ok",
+    names,
+    confirmed,
+    fcrdns: confirmed ? true : answered ? false : null,
+    generic: isGenericPtr(confirmed ?? names[0]!, ip),
+  };
+}
+
+async function networkIntel(resolve: DnsResolver, ip: string): Promise<IpIntel["network"]> {
+  const empty = { asn: null, asName: null, prefix: null, country: null, registry: null };
+  const zone = ip.includes(":") ? "origin6.asn.cymru.com" : "origin.asn.cymru.com";
+  const origin = await resolve(`${reversedIp(ip)}.${zone}`, "TXT");
+  const parsed = origin.records.map(parseCymruOrigin).find(Boolean) ?? null;
+  if (!parsed) {
+    return { status: origin.status === "ok" ? "nxdomain" : origin.status, ...empty };
+  }
+  const name = await resolve(`AS${parsed.asn}.asn.cymru.com`, "TXT");
+  return {
+    status: "ok",
+    ...parsed,
+    asName: name.records.map(parseCymruAsName).find(Boolean) ?? null,
+  };
+}
+
+/** PTR → forward confirmation and Team Cymru origin → AS name, in parallel. */
+export async function lookupIpIntel(resolve: DnsResolver, ip: string): Promise<IpIntel> {
+  const [ptr, network] = await Promise.all([ptrIntel(resolve, ip), networkIntel(resolve, ip)]);
+  return { ptr, network };
+}
+
+export function heloMatchesPtr(helo: string | null, ptr: IpIntel["ptr"]) {
+  if (!helo || !ptr.names.length) return null;
+  const name = helo.toLocaleLowerCase().replace(/\.$/u, "");
+  const org = organizationalDomain(name);
+  return ptr.names.some((candidate) =>
+    candidate === name || (org !== null && organizationalDomain(candidate) === org)
+  );
+}
+
+/** Per-IP results are cacheable; timeouts and errors are not. */
+export function ipIntelCacheTtl(intel: IpIntel) {
+  const failed = (status: string) => status === "timeout" || status === "error";
+  if (failed(intel.ptr.status) || failed(intel.network.status)) return 0;
+  if (intel.ptr.status === "nxdomain" || intel.network.status === "nxdomain") return 3_600;
+  return 86_400;
+}

package/worker/mail/link-domains.ts

@@ -0,0 +1,57 @@
+import { parse } from "tldts";
+import { normalizeIp } from "../../shared/mail-received";
+import { isWorkspaceDomain } from "./message-security";
+import { organizationalDomain } from "./org-domain";
+
+export const MAX_LINK_DOMAINS = 10;
+const MAX_SCAN_CHARACTERS = 512 * 1024;
+
+function hostDomain(value: string) {
+  try {
+    const url = new URL(value.replaceAll("&", "&"));
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    const host = url.hostname.replace(/^\[|\]$/gu, "");
+    if (normalizeIp(host)) return null;
+    return organizationalDomain(host);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Registrable domains of the links in a message, in order of first
+ * appearance, without the workspace's own domains. Used for Spamhaus DBL.
+ */
+export function linkDomains(input: {
+  html?: string | null;
+  text?: Array<string | null | undefined>;
+  workspaceDomains?: readonly string[];
+  limit?: number;
+}) {
+  const candidates: string[] = [];
+  const html = input.html?.slice(0, MAX_SCAN_CHARACTERS) ?? "";
+  for (const match of html.matchAll(/\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/giu)) {
+    candidates.push((match[1] ?? match[2] ?? match[3] ?? "").trim());
+  }
+  // Visible text only: image sources and other attributes are not links.
+  const visible = html.replace(/<[^>]*>/gu, " ");
+  const text = [visible, ...(input.text ?? [])].filter(Boolean).join("\n").slice(0, MAX_SCAN_CHARACTERS * 2);
+  for (const match of text.matchAll(/\bhttps?:\/\/[^\s<>"'()[\]{}]+/giu)) {
+    candidates.push(match[0]);
+  }
+  // Scheme-less links people still click, such as "goo.gl/0667" typed into a
+  // field a platform echoes back. A path is required so file names and plain
+  // domains in prose are left alone.
+  for (const match of text.matchAll(/(?<![@\w./-])((?:[a-z0-9-]+\.)+[a-z]{2,24})\/[^\s<>"'()[\]{}]*/giu)) {
+    if (parse(match[1]!).isIcann) candidates.push(`https://${match[0]}`);
+  }
+  const domains: string[] = [];
+  for (const candidate of candidates) {
+    const domain = hostDomain(candidate);
+    if (!domain || domains.includes(domain)) continue;
+    if (isWorkspaceDomain(domain, input.workspaceDomains ?? [])) continue;
+    domains.push(domain);
+    if (domains.length >= (input.limit ?? MAX_LINK_DOMAINS)) break;
+  }
+  return domains;
+}

package/worker/mail/mailbox-deletion.ts

@@ -0,0 +1,18 @@
+import { mailboxStub } from "../mailbox";
+
+async function deleteMailboxObjects(bucket: R2Bucket, mailboxId: string) {
+  const prefix = `mailboxes/${mailboxId}/`;
+  while (true) {
+    const page = await bucket.list({ prefix, limit: 1_000 });
+    const keys = page.objects.map((object) => object.key);
+    if (!keys.length) return;
+    await bucket.delete(keys);
+  }
+}
+
+export async function deleteMailboxStorage(env: Env, mailboxId: string) {
+  await Promise.all([
+    mailboxStub(env, mailboxId).deleteMailboxData(),
+    deleteMailboxObjects(env.MAIL_STORAGE, mailboxId),
+  ]);
+}

package/worker/mail/mailbox-directory.ts

@@ -0,0 +1,73 @@
+type ActiveMailboxSessionRow = {
+  id: string;
+  token_hash: string;
+  user_id: string;
+};
+
+export type ActiveMailboxSession = {
+  id: string;
+  tokenHash: string;
+  userId: string;
+};
+
+type MailboxUserRow = {
+  id: string;
+  name: string;
+};
+
+function idList(ids: string[]) {
+  return JSON.stringify([...new Set(ids)]);
+}
+
+export async function listActiveMailboxSessions(
+  db: D1Database,
+  mailboxId: string,
+  sessionIds: string[],
+  now: number,
+): Promise<ActiveMailboxSession[]> {
+  if (!sessionIds.length) return [];
+  // D1 allows only 100 bound parameters, so the complete ID set is bound as
+  // one JSON value and expanded by SQLite instead of generating a large IN.
+  const result = await db.prepare(`
+    with requested_sessions(id) as (
+      select cast(value as text) from json_each(?)
+    )
+    select
+      session.id,
+      session.token_hash,
+      session.user_id
+    from requested_sessions requested
+    inner join sessions session on session.id = requested.id
+    inner join users user on user.id = session.user_id
+    inner join mailbox_access member
+      on member.user_id = session.user_id
+      and member.mailbox_id = ?
+    where session.expires_at > ?
+      and user.status = 'active'
+  `).bind(idList(sessionIds), mailboxId, now).all<ActiveMailboxSessionRow>();
+  return result.results.map((session) => ({
+    id: session.id,
+    tokenHash: session.token_hash,
+    userId: session.user_id,
+  }));
+}
+
+export async function listMailboxUsersByIds(
+  db: D1Database,
+  mailboxId: string,
+  userIds: string[],
+) {
+  if (!userIds.length) return [];
+  const result = await db.prepare(`
+    with requested_users(id) as (
+      select cast(value as text) from json_each(?)
+    )
+    select user.id, user.name
+    from requested_users requested
+    inner join mailbox_access member
+      on member.user_id = requested.id
+      and member.mailbox_id = ?
+    inner join users user on user.id = member.user_id
+  `).bind(idList(userIds), mailboxId).all<MailboxUserRow>();
+  return result.results;
+}

package/worker/mail/mailing-list.ts

@@ -0,0 +1,120 @@
+import { and, eq, sql } from "drizzle-orm";
+import PostalMime from "postal-mime";
+import type { ListPostingPolicy } from "@open-workspace/core/shared/workspace.ts";
+import { createDb } from "@open-workspace/core/worker/db/client.ts";
+import { mailboxAddressSql } from "@open-workspace/core/worker/db/mailboxes.ts";
+import { domains, mailboxAccess, mailboxes, teamMembership, users } from "@open-workspace/core/worker/db/schema.ts";
+import { emailDomain, normalizeEmail, normalizeMailboxAddress } from "@open-workspace/core/worker/lib/ids.ts";
+import { mailboxStub } from "../mailbox";
+import { parseInboundAuthentication } from "./auth-headers";
+import { inboundDeliveryId } from "./inbound-delivery";
+import { rawHeaderText } from "./inbound";
+
+export type MailingList = {
+  id: string;
+  teamId: string;
+  listPosting: ListPostingPolicy;
+};
+
+/** The primary mailbox of each active member: where their copy lands. */
+async function memberMailboxIds(db: D1Database, teamId: string) {
+  const rows = await createDb(db)
+    .selectDistinct({ id: mailboxes.id })
+    .from(teamMembership)
+    .innerJoin(users, and(eq(users.id, teamMembership.userId), eq(users.status, "active")))
+    .innerJoin(mailboxes, and(
+      eq(mailboxes.ownerUserId, teamMembership.userId),
+      eq(mailboxes.isPrimary, true),
+    ))
+    .where(eq(teamMembership.teamId, teamId));
+  return rows.map((row) => row.id);
+}
+
+/**
+ * The verified sender of a message, when its From domain passed DMARC at
+ * Cloudflare. Anything else may be forged and grants no posting rights.
+ */
+async function verifiedSender(rawMime: ArrayBuffer) {
+  let from: string | null = null;
+  try {
+    from = (await PostalMime.parse(rawHeaderText(rawMime))).from?.address ?? null;
+  } catch {
+    return null;
+  }
+  if (!from) return null;
+  const authentication = parseInboundAuthentication({ raw: rawHeaderText(rawMime), fromAddress: from });
+  const sender = normalizeEmail(from);
+  return authentication.dmarc?.result === "pass"
+    && authentication.dmarc.headerFrom === emailDomain(sender)
+    ? sender
+    : null;
+}
+
+async function mayPost(db: D1Database, list: MailingList, rawMime: ArrayBuffer) {
+  if (list.listPosting === "anyone") return true;
+  const sender = await verifiedSender(rawMime);
+  if (!sender) return false;
+  const orm = createDb(db);
+  const [mailbox] = await orm
+    .select({ id: mailboxes.id })
+    .from(mailboxes)
+    .innerJoin(domains, eq(domains.id, mailboxes.domainId))
+    .where(sql`${mailboxAddressSql} = ${sender}`)
+    .limit(1);
+  if (!mailbox) return false;
+  if (list.listPosting === "workspace") return true;
+  // Members post from any address they may send from.
+  const [member] = await orm
+    .select({ userId: mailboxAccess.userId })
+    .from(mailboxAccess)
+    .innerJoin(teamMembership, and(
+      eq(teamMembership.userId, mailboxAccess.userId),
+      eq(teamMembership.teamId, list.teamId),
+    ))
+    .where(and(eq(mailboxAccess.mailboxId, mailbox.id), eq(mailboxAccess.canSend, true)))
+    .limit(1);
+  return Boolean(member);
+}
+
+/**
+ * Copies mail sent to a team's mailing list into each member's own mailbox.
+ * The copies share one stored original and never leave the workspace.
+ */
+export async function deliverToList(input: {
+  env: Env;
+  list: MailingList;
+  message: { from: string; to: string; setReject(reason: string): void };
+  raw: ArrayBuffer;
+  receivedAt: number;
+}) {
+  const { env, list, message, raw } = input;
+  if (!(await mayPost(env.DB, list, raw))) {
+    message.setReject(`You are not allowed to post to ${normalizeMailboxAddress(message.to)}`);
+    return;
+  }
+  const recipients = await memberMailboxIds(env.DB, list.teamId);
+  if (!recipients.length) return;
+  const listAddress = normalizeMailboxAddress(message.to);
+  const deliveryId = await inboundDeliveryId({
+    mailboxId: list.id,
+    envelopeFrom: message.from,
+    envelopeTo: message.to,
+    raw,
+  });
+  const objectKey = `lists/${list.id}/raw/${deliveryId}.eml`;
+  await Promise.all(recipients.map(async (mailboxId) => mailboxStub(env, mailboxId).enqueueInbound({
+    id: await inboundDeliveryId({
+      mailboxId,
+      envelopeFrom: message.from,
+      envelopeTo: message.to,
+      raw,
+    }),
+    mailboxId,
+    rawObjectKey: objectKey,
+    envelopeFrom: message.from,
+    envelopeTo: message.to,
+    listAddress,
+    receivedAt: input.receivedAt,
+  })));
+  await env.MAIL_STORAGE.put(objectKey, raw, { httpMetadata: { contentType: "message/rfc822" } });
+}

package/worker/mail/message-security.ts

@@ -0,0 +1,190 @@
+import type {
+  InboundAuthentication,
+  ListUnsubscribe,
+  MessageSecurity,
+} from "../../shared/mail-authentication";
+import { addressDomain } from "../../shared/mail-headers";
+import type { DeliveryFacts, SecurityWarning, SenderIntel } from "../../shared/mail-sender-intel";
+import { addressedElsewhereWarning } from "./delivery-facts";
+import { embeddedAddress, impersonatedName, lookalikeOf } from "./impersonation";
+import { organizationalDomain, relaxedAligned } from "./org-domain";
+
+export function isWorkspaceDomain(domain: string | null, workspaceDomains: readonly string[]) {
+  if (!domain) return false;
+  return workspaceDomains.some((candidate) => {
+    const name = candidate.toLocaleLowerCase();
+    return domain === name || domain.endsWith(`.${name}`);
+  });
+}
+
+/** Mailbox-local history for the From address (`senders` table). */
+export type SenderHistory = {
+  inboundCount: number;
+  outboundCount: number;
+};
+
+const warningOrder: Record<SecurityWarning["kind"], number> = {
+  dbl_listed: 0,
+  lookalike_domain: 1,
+  display_name_impersonation: 2,
+  addressed_elsewhere: 3,
+  zen_listed: 4,
+  unverified_sender: 5,
+  embedded_address: 6,
+  reply_to_mismatch: 7,
+};
+
+/**
+ * The first Reply-To address whose organizational domain differs from the
+ * From organizational domain. Mailing lists legitimately redirect replies.
+ */
+export function replyToMismatch(input: {
+  fromAddress: string;
+  replyTo: readonly string[];
+  listId: string | null;
+}) {
+  if (input.listId) return null;
+  const fromOrg = organizationalDomain(input.fromAddress);
+  if (!fromOrg) return null;
+  for (const address of input.replyTo) {
+    const domain = organizationalDomain(address);
+    if (domain && domain !== fromOrg) return { address: address.toLocaleLowerCase(), domain };
+  }
+  return null;
+}
+
+/**
+ * Prioritized warnings for one message, most serious first. The reader shows
+ * the first as the banner headline and folds the rest into it.
+ */
+export function securityWarnings(input: {
+  fromAddress: string;
+  fromName: string | null;
+  external: boolean;
+  fromDomain: string | null;
+  authentication: InboundAuthentication | null;
+  intel: SenderIntel | null;
+  workspaceDomains: readonly string[];
+  internalNames: ReadonlyMap<string, string>;
+  history: SenderHistory | null;
+  replyTo?: readonly string[];
+  listId?: string | null;
+  delivery?: DeliveryFacts | null;
+  /** Trusted senders keep only danger-level warnings. */
+  trusted?: boolean;
+}): SecurityWarning[] {
+  const warnings: SecurityWarning[] = [];
+  const spamhaus = input.intel?.spamhaus;
+  const dbl = spamhaus?.dbl.listings ?? [];
+  if (dbl.length) {
+    const fromOrg = organizationalDomain(input.fromDomain);
+    warnings.push({
+      kind: "dbl_listed",
+      severity: "danger",
+      domains: [...new Set(dbl.map((listing) => listing.target))],
+      lists: [...new Set(dbl.map((listing) => listing.list))],
+      senderDomain: dbl.some((listing) => listing.target === fromOrg),
+    });
+  }
+  const zen = spamhaus?.zen.listings ?? [];
+  if (zen.length && input.intel?.ip) {
+    warnings.push({
+      kind: "zen_listed",
+      severity: zen.some((listing) => listing.severity === "abuse") ? "danger" : "caution",
+      ip: input.intel.ip,
+      lists: [...new Set(zen.map((listing) => listing.list))],
+    });
+  }
+  if (input.external) {
+    const lookalike = lookalikeOf(input.fromDomain, input.workspaceDomains);
+    if (lookalike) warnings.push({ kind: "lookalike_domain", severity: "danger", ...lookalike });
+    // Someone this mailbox has written to before (a colleague's personal
+    // address) is an established correspondent, not an impersonator.
+    const name = impersonatedName(input.fromName, input.internalNames);
+    if (name && !(input.history && input.history.outboundCount > 0)) {
+      warnings.push({ kind: "display_name_impersonation", severity: "danger", name });
+    }
+    const claimed = embeddedAddress(input.fromName, input.fromAddress);
+    if (claimed) warnings.push({ kind: "embedded_address", severity: "caution", claimed });
+  }
+  if (input.authentication?.verdict === "suspicious") {
+    warnings.push({ kind: "unverified_sender", severity: "caution", domain: input.fromDomain });
+  }
+  const mismatch = replyToMismatch({
+    fromAddress: input.fromAddress,
+    replyTo: input.replyTo ?? [],
+    listId: input.listId ?? null,
+  });
+  if (mismatch) warnings.push({ kind: "reply_to_mismatch", severity: "caution", ...mismatch });
+  const elsewhere = addressedElsewhereWarning(input.delivery ?? null, input.fromDomain);
+  if (elsewhere) warnings.push(elsewhere);
+  return warnings
+    .filter((warning) => !input.trusted || warning.severity === "danger")
+    .sort((left, right) => warningOrder[left.kind] - warningOrder[right.kind]);
+}
+
+/** Gmail-style sender summary derived from the stored authentication results. */
+export function messageSecurity(input: {
+  fromAddress: string;
+  fromName?: string | null;
+  authentication: InboundAuthentication | null;
+  listUnsubscribe: ListUnsubscribe | null;
+  workspaceDomains: readonly string[];
+  internalNames?: ReadonlyMap<string, string>;
+  intel?: SenderIntel | null;
+  history?: SenderHistory | null;
+  replyTo?: readonly string[];
+  listId?: string | null;
+  delivery?: DeliveryFacts | null;
+  trusted?: boolean;
+}): MessageSecurity {
+  const auth = input.authentication;
+  const fromDomain = addressDomain(input.fromAddress) ?? auth?.fromDomain ?? null;
+  const passing = auth?.dkim.filter((dkim) => dkim.result === "pass") ?? [];
+  const alignedDkim = passing.find((dkim) => dkim.aligned);
+  const signedBy = (alignedDkim ?? passing[0])?.domain ?? null;
+  const mailedBy = auth?.spf?.domain ?? addressDomain(auth?.envelopeFrom) ?? null;
+  let via: string | null = null;
+  if (auth && auth.verdict !== "unavailable" && !alignedDkim) {
+    const spfAligned = auth.spf?.result === "pass" && auth.spf.aligned;
+    const candidate = signedBy ?? (spfAligned ? null : mailedBy);
+    via = candidate && !relaxedAligned(candidate, fromDomain) ? candidate : null;
+  }
+  const external = !isWorkspaceDomain(fromDomain, input.workspaceDomains);
+  const history = input.history ?? null;
+  return {
+    verdict: auth?.verdict ?? "unavailable",
+    verdictReason: auth?.verdictReason ?? "not_cloudflare",
+    fromDomain,
+    mailedBy,
+    signedBy,
+    via,
+    forwardedVia: input.delivery?.forwardedVia ?? null,
+    external,
+    listUnsubscribe: input.listUnsubscribe,
+    warnings: securityWarnings({
+      fromAddress: input.fromAddress,
+      fromName: input.fromName ?? null,
+      external,
+      fromDomain,
+      authentication: auth,
+      intel: input.intel ?? null,
+      workspaceDomains: input.workspaceDomains,
+      internalNames: input.internalNames ?? new Map(),
+      history,
+      replyTo: input.replyTo,
+      listId: input.listId,
+      delivery: input.delivery,
+      trusted: input.trusted,
+    }),
+    firstTimeSender: Boolean(
+      !input.trusted && external && history && history.inboundCount <= 1 && history.outboundCount === 0,
+    ),
+    replyToMismatch: replyToMismatch({
+      fromAddress: input.fromAddress,
+      replyTo: input.replyTo ?? [],
+      listId: input.listId ?? null,
+    }),
+    trusted: Boolean(input.trusted),
+  };
+}

package/worker/mail/message-view.ts

@@ -0,0 +1,63 @@
+import type { SenderStatus, Unsubscription } from "../../shared/mail-feedback";
+import { workspaceBlockFor } from "../mailbox/senders";
+import type { Email } from "../mailbox/schema";
+import { headerAuthentication } from "./header-metadata";
+import { messageSecurity, type SenderHistory } from "./message-security";
+import type { WorkspaceIdentity } from "./security-settings";
+import { storedSenderIntel } from "./sender-intel";
+import { unsubscribeListKey } from "./unsubscribe";
+
+export type MessageSafetyContext = {
+  senders: Record<string, SenderStatus>;
+  unsubscriptions: Record<string, Unsubscription>;
+  workspaceBlocks: ReadonlyMap<string, number>;
+};
+
+const emptySafetyContext: MessageSafetyContext = {
+  senders: {},
+  unsubscriptions: {},
+  workspaceBlocks: new Map(),
+};
+
+/** Block, trust and report state for the sender, with workspace blocks taking precedence. */
+export function senderStatus(email: Email, safety: MessageSafetyContext): SenderStatus | null {
+  if (email.direction !== "incoming") return null;
+  const address = email.fromJson[0]?.address.toLocaleLowerCase() ?? "";
+  const local = safety.senders[address];
+  return {
+    block: workspaceBlockFor(address, safety.workspaceBlocks) ?? local?.block ?? null,
+    trustedAt: local?.trustedAt ?? null,
+    reportedAt: local?.reportedAt ?? null,
+  };
+}
+
+export function emailListKey(email: Email) {
+  return email.direction === "incoming"
+    ? unsubscribeListKey({ listId: email.listId, fromAddress: email.fromJson[0]?.address ?? null })
+    : null;
+}
+
+export function emailSecurity(
+  email: Email,
+  identity: WorkspaceIdentity,
+  history: Record<string, SenderHistory>,
+  safety: MessageSafetyContext = emptySafetyContext,
+) {
+  if (email.direction !== "incoming") return null;
+  const from = email.fromJson[0] ?? { address: "", name: null };
+  const status = senderStatus(email, safety);
+  return messageSecurity({
+    fromAddress: from.address,
+    fromName: from.name,
+    authentication: headerAuthentication(email),
+    listUnsubscribe: email.listUnsubscribeJson ?? null,
+    workspaceDomains: identity.domains,
+    internalNames: identity.names,
+    intel: storedSenderIntel(email.senderIntelJson),
+    history: history[from.address.toLocaleLowerCase()] ?? null,
+    replyTo: email.replyToJson.map((item) => item.address),
+    listId: email.listId,
+    delivery: email.deliveryJson ?? null,
+    trusted: Boolean(status?.trustedAt) && !status?.block,
+  });
+}