@open-workspace/email 0.0.0-stage → 0.1.0

package/worker/mail/outbound.ts

@@ -0,0 +1,446 @@
+import type { z } from "zod";
+import {
+  attachmentsRequiringDownloadLinks,
+  composerAttachmentLimitError,
+  isComposerInlineImageContentType,
+} from "../../shared/mail";
+import { hashToken, randomToken } from "@open-workspace/core/worker/lib/crypto.ts";
+import type { StoredAttachment } from "../mailbox/model";
+import type { Email, NewEmail } from "../mailbox/schema";
+import {
+  appendForwardedMessage,
+  contextForNewRecipient,
+  escapeHtml,
+  externalizeLinkedInlineImages,
+  htmlWithQuotedContext,
+  resolveLinkedAttachmentPlaceholders,
+  textWithQuotedContext,
+} from "./outbound-content";
+import {
+  address,
+  replyThreadHeaders,
+} from "./rfc";
+import type { composeSchema } from "./schemas";
+import {
+  copyStoredAttachmentToMessage,
+  loadComposerUpload,
+  loadComposerUploadMetadata,
+  UploadValidationError,
+} from "./uploads";
+
+const DOWNLOAD_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+export type OutgoingMessageInput = z.infer<typeof composeSchema> & {
+  /** Set by the route from the authenticated session. */
+  userId: string;
+};
+type PreparedAttachment = StoredAttachment & {
+  downloadUrl: string | null;
+  sourceUploadId?: string;
+  sourceObjectKey?: string;
+};
+
+export class ComposerAttachmentLimitError extends Error {}
+
+type OutgoingAttachmentDraft = Pick<
+  OutgoingMessageInput,
+  | "attachments"
+  | "bodyHtml"
+  | "bodyText"
+  | "mailboxId"
+  | "subject"
+  | "userId"
+>;
+
+export async function discardPreparedObjects(env: Env, storageKeys: string[]) {
+  if (!storageKeys.length) return;
+  try {
+    await env.MAIL_STORAGE.delete(storageKeys);
+  } catch (error) {
+    // Attempt-scoped keys cannot corrupt the winning idempotent request.
+    console.error("Could not remove unused outgoing mail objects", error);
+  }
+}
+
+export async function outgoingRequestFingerprint(compose: OutgoingMessageInput) {
+  const { userId: _, ...payload } = compose;
+  return hashToken(`outgoing-request-v2\0${JSON.stringify(payload)}`);
+}
+
+export { attachmentsRequiringDownloadLinks };
+
+export function withDownloadLinks(
+  bodyText: string,
+  bodyHtml: string | undefined,
+  attachments: PreparedAttachment[],
+  expiresAt: Date,
+) {
+  const positioned = resolveLinkedAttachmentPlaceholders({
+    bodyText,
+    bodyHtml,
+    attachments: attachments.map((attachment) => ({
+      uploadId: attachment.sourceUploadId ?? null,
+      filename: attachment.filename,
+      downloadUrl: attachment.downloadUrl,
+    })),
+  });
+  const links = attachments.filter(
+    (attachment): attachment is PreparedAttachment & { downloadUrl: string } =>
+      attachment.downloadUrl !== null,
+  );
+  if (!links.length) {
+    return {
+      bodyText: positioned.bodyText,
+      bodyHtml: positioned.bodyHtml,
+    };
+  }
+
+  const expiry = expiresAt.toISOString().slice(0, 10);
+  const fallbackTextLinks = links.filter(
+    (attachment) =>
+      !attachment.sourceUploadId
+      || !positioned.textPlacedUploadIds.has(attachment.sourceUploadId),
+  );
+  const textBlock = fallbackTextLinks.length
+    ? [
+        `Attachments (download links expire ${expiry}):`,
+        ...fallbackTextLinks.map((attachment) =>
+          `- ${attachment.filename}: ${attachment.downloadUrl}`
+        ),
+      ].join("\n")
+    : "";
+  const nextText = textBlock
+    ? `${positioned.bodyText.trimEnd()}${positioned.bodyText.trimEnd() ? "\n\n" : ""}${textBlock}`
+    : positioned.bodyText;
+  if (!positioned.bodyHtml) {
+    return { bodyText: nextText, bodyHtml: positioned.bodyHtml };
+  }
+
+  const inlineImagePlacements = new Set(
+    links.flatMap((attachment) =>
+      attachment.disposition === "inline"
+        && attachment.contentId
+        && positioned.bodyHtml!.includes(`cid:${attachment.contentId}`)
+        ? [attachment.id]
+        : []
+    ),
+  );
+  const nextHtml = externalizeLinkedInlineImages(positioned.bodyHtml, links);
+  const fallbackHtmlLinks = links.filter(
+    (attachment) =>
+      (
+        !attachment.sourceUploadId
+        || !positioned.htmlPlacedUploadIds.has(attachment.sourceUploadId)
+      )
+      && !inlineImagePlacements.has(attachment.id),
+  );
+  if (!fallbackHtmlLinks.length) {
+    return { bodyText: nextText, bodyHtml: nextHtml };
+  }
+
+  const htmlBlock = [
+    `<p>Attachments (download links expire ${escapeHtml(expiry)}):</p>`,
+    "<ul>",
+    ...fallbackHtmlLinks.map((attachment) =>
+      `<li><a href="${escapeHtml(attachment.downloadUrl)}">${escapeHtml(attachment.filename)}</a></li>`,
+    ),
+    "</ul>",
+  ].join("");
+  return { bodyText: nextText, bodyHtml: `${nextHtml}${htmlBlock}` };
+}
+
+export async function messageIdForRequest(mailboxId: string, requestId: string) {
+  return `msg_${await hashToken(`${mailboxId}:${requestId}`)}`;
+}
+
+async function loadPreparedComposerAttachments(input: {
+  env: Env;
+  compose: OutgoingAttachmentDraft;
+  storagePrefix: string;
+  finalized: boolean;
+}) {
+  const loadUpload = input.finalized
+    ? loadComposerUpload
+    : loadComposerUploadMetadata;
+  return Promise.all(
+    input.compose.attachments.map(async (file, index) => {
+      try {
+        const upload = await loadUpload({
+          env: input.env,
+          mailboxId: input.compose.mailboxId,
+          userId: input.compose.userId,
+          uploadId: file.uploadId,
+        });
+        if (
+          file.disposition === "inline"
+          && !isComposerInlineImageContentType(upload.contentType)
+        ) {
+          throw new UploadValidationError(
+            "Inline images must be PNG, JPEG, GIF, or WebP",
+          );
+        }
+        return {
+          id: `att_${index + 1}`,
+          sourceUploadId: file.uploadId,
+          sourceObjectKey: upload.r2Key,
+          r2Key: `${input.storagePrefix}/attachments/att_${index + 1}`,
+          filename: upload.filename,
+          contentType: upload.contentType,
+          size: upload.size,
+          contentId: file.contentId ?? null,
+          disposition: file.disposition,
+          delivery: "attached" as const,
+          downloadTokenHash: null,
+          downloadExpiresAt: null,
+          downloadUrl: null,
+        } satisfies PreparedAttachment;
+      } catch (error) {
+        if (error instanceof UploadValidationError) {
+          throw new ComposerAttachmentLimitError(error.message);
+        }
+        throw error;
+      }
+    }),
+  );
+}
+
+function planOutgoingAttachments(input: {
+  compose: OutgoingAttachmentDraft;
+  uploaded: PreparedAttachment[];
+  forwarded: Email | null;
+  related: Email | null;
+  includeRelatedContext: boolean;
+  storagePrefix?: string;
+}) {
+  // A persisted forward gets message-owned copies. Preflight has no storage
+  // prefix and only needs attachment metadata for the delivery plan.
+  const forwardedAttachments: PreparedAttachment[] = (
+    input.forwarded?.attachmentsJson ?? []
+  ).map((file, index) => {
+    const id = `fwd_att_${index + 1}`;
+    return {
+      ...file,
+      id,
+      r2Key: input.storagePrefix
+        ? `${input.storagePrefix}/attachments/${id}`
+        : file.r2Key,
+      sourceObjectKey: input.storagePrefix ? file.r2Key : undefined,
+      contentId: null,
+      disposition: "attachment",
+      delivery: "attached",
+      downloadTokenHash: null,
+      downloadExpiresAt: null,
+      downloadUrl: null,
+    };
+  });
+  const attachments = [...input.uploaded, ...forwardedAttachments];
+  const limitError = composerAttachmentLimitError(attachments);
+  if (limitError) throw new ComposerAttachmentLimitError(limitError);
+  const forwardedContent = appendForwardedMessage(
+    input.compose.bodyText,
+    input.compose.bodyHtml,
+    input.forwarded,
+  );
+  const quotedText = input.includeRelatedContext && input.related
+    ? contextForNewRecipient(input.related)
+    : null;
+  const linkedIds = attachmentsRequiringDownloadLinks({
+    subject: input.compose.subject,
+    bodyText: textWithQuotedContext(forwardedContent.bodyText, quotedText),
+    bodyHtml: forwardedContent.bodyHtml
+      ? htmlWithQuotedContext(forwardedContent.bodyHtml, quotedText)
+      : undefined,
+    attachments,
+  });
+  return {
+    attachments,
+    forwardedContent,
+    linkedIds,
+    quotedText,
+  };
+}
+
+export async function preflightOutgoingAttachments(input: {
+  env: Env;
+  compose: OutgoingAttachmentDraft;
+  forwarded: Email | null;
+  related: Email | null;
+  includeRelatedContext: boolean;
+}) {
+  const uploaded = await loadPreparedComposerAttachments({
+    env: input.env,
+    compose: input.compose,
+    storagePrefix: "preflight",
+    finalized: false,
+  });
+  const plan = planOutgoingAttachments({
+    ...input,
+    uploaded,
+  });
+  return {
+    externalizedAttachments: plan.linkedIds.size,
+    linkedUploadIds: uploaded.flatMap((attachment) =>
+      plan.linkedIds.has(attachment.id) && attachment.sourceUploadId
+        ? [attachment.sourceUploadId]
+        : []
+    ),
+  };
+}
+
+export async function prepareOutgoingEmail(input: {
+  env: Env;
+  requestUrl: string;
+  compose: OutgoingMessageInput;
+  requestFingerprint: string;
+  id: string;
+  conversationId: string;
+  related: Email | null;
+  forwarded: Email | null;
+  includeRelatedContext: boolean;
+  fromAddress: string;
+  fromName: string;
+  now: Date;
+}) {
+  const { compose, id, related } = input;
+  const storageAttempt = randomToken();
+  const storagePrefix = `mailboxes/${compose.mailboxId}/messages/${id}/attempts/${storageAttempt}`;
+  const expiresAt = new Date(input.now.getTime() + DOWNLOAD_TTL_MS);
+
+  const uploaded = await loadPreparedComposerAttachments({
+    env: input.env,
+    compose,
+    storagePrefix,
+    finalized: true,
+  });
+  const plan = planOutgoingAttachments({
+    compose,
+    uploaded,
+    forwarded: input.forwarded,
+    related,
+    includeRelatedContext: input.includeRelatedContext,
+    storagePrefix,
+  });
+  const {
+    forwardedContent,
+    linkedIds,
+    quotedText,
+  } = plan;
+  const attachments: PreparedAttachment[] = await Promise.all(
+    plan.attachments.map(async (file) => {
+      if (!linkedIds.has(file.id)) return file;
+      const token = `${compose.mailboxId}.${id}.${file.id}.${randomToken()}`;
+      return {
+        ...file,
+        delivery: "download_link" as const,
+        downloadTokenHash: await hashToken(token),
+        downloadExpiresAt: expiresAt.getTime(),
+        downloadUrl: new URL(
+          `/api/downloads/mail/${encodeURIComponent(token)}`,
+          input.requestUrl,
+        ).toString(),
+      };
+    }),
+  );
+  const content = withDownloadLinks(
+    forwardedContent.bodyText,
+    forwardedContent.bodyHtml,
+    attachments,
+    expiresAt,
+  );
+  // The stored body is the authored content only. Quoted context is persisted
+  // separately and added to the transport payload at delivery time.
+  const storedBodyHtml = content.bodyHtml;
+  const bodyHtmlR2Key = storedBodyHtml
+    ? `${storagePrefix}/body.html`
+    : null;
+
+  const storageKeys = [
+    ...attachments.flatMap((file) =>
+      file.sourceObjectKey ? [file.r2Key] : []
+    ),
+    ...(bodyHtmlR2Key ? [bodyHtmlR2Key] : []),
+  ];
+  const writes = [
+    ...attachments.flatMap((file) => {
+      if (!file.sourceObjectKey) return [];
+      return [
+        copyStoredAttachmentToMessage({
+          env: input.env,
+          sourceKey: file.sourceObjectKey,
+          destinationKey: file.r2Key,
+          contentType: file.contentType,
+        }),
+      ];
+    }),
+    ...(bodyHtmlR2Key && storedBodyHtml
+      ? [input.env.MAIL_STORAGE.put(bodyHtmlR2Key, storedBodyHtml, {
+          httpMetadata: { contentType: "text/html; charset=utf-8" },
+        })]
+      : []),
+  ];
+  const writeResults = await Promise.allSettled(writes);
+  const failedWrite = writeResults.find(
+    (result): result is PromiseRejectedResult => result.status === "rejected",
+  );
+  if (failedWrite) {
+    await discardPreparedObjects(input.env, storageKeys);
+    throw failedWrite.reason;
+  }
+
+  const from = address(input.fromAddress, input.fromName);
+  const to = compose.to.map((value) => address(value));
+  const cc = compose.cc.map((value) => address(value));
+  const bcc = compose.bcc.map((value) => address(value));
+  const replyTo = compose.replyTo ? [address(compose.replyTo)] : [];
+  const threadHeaders = related
+    ? replyThreadHeaders(related)
+    : { inReplyTo: [], references: [] };
+  const continuedList = related?.conversationId === input.conversationId
+    ? related
+    : null;
+  const email: NewEmail = {
+    id,
+    requestFingerprint: input.requestFingerprint,
+    conversationId: input.conversationId,
+    direction: "outgoing",
+    messageIdHeader: null,
+    inReplyToJson: threadHeaders.inReplyTo,
+    referencesJson: threadHeaders.references,
+    fromJson: [from],
+    replyToJson: replyTo,
+    toJson: to,
+    ccJson: cc,
+    bccJson: bcc,
+    subject: compose.subject || "(no subject)",
+    preview: content.bodyText
+      .replace(/\s+/gu, " ")
+      .trim()
+      .slice(0, 220),
+    bodyText: content.bodyText,
+    quotedText,
+    bodyHtmlR2Key,
+    attachmentsJson: attachments.map(
+      ({
+        downloadUrl: _,
+        sourceUploadId: __,
+        sourceObjectKey: ___,
+        ...file
+      }) => file,
+    ),
+    listId: continuedList?.listId ?? null,
+    listPostAddress: continuedList?.listPostAddress ?? null,
+    timelineAt: input.now,
+    transportState: "unconfirmed",
+    deliveryStatusJson: [],
+  };
+  return {
+    email,
+    externalizedAttachments: linkedIds.size,
+    // Every key is owned by this attempt, including forwarded attachment
+    // copies, so rollback cannot remove an object owned by another message.
+    storageKeys,
+    composerUploadIds: uploaded.flatMap((file) =>
+      file.sourceUploadId ? [file.sourceUploadId] : []
+    ),
+  };
+}

package/worker/mail/outgoing-context.ts

@@ -0,0 +1,122 @@
+import {
+  forwardSubject,
+  MAX_MAIL_RECIPIENTS,
+  replySubject,
+  type ReplyActionMode,
+} from "../../shared/mail";
+import { mailboxStub } from "../mailbox";
+import type { Email } from "../mailbox/schema";
+import { hasNewRecipients, shouldDetachOutboundReply } from "./outbound-threading";
+import {
+  dedupeRecipientFields,
+  recipientCount,
+  type RecipientFields,
+} from "./recipients";
+import { buildReplyPlan, canReplyFrom } from "./reply-plan";
+
+type OutgoingContextCode = "BAD_REQUEST" | "NOT_FOUND" | "NOT_READY";
+
+export class OutgoingContextError extends Error {
+  constructor(
+    readonly status: 400 | 404 | 409,
+    readonly code: OutgoingContextCode,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+export async function resolveForwardContext(input: {
+  env: Env;
+  mailboxId: string;
+  sourceEmailId: string;
+}) {
+  const source = await mailboxStub(input.env, input.mailboxId)
+    .getEmail(input.sourceEmailId);
+  if (!source) {
+    throw new OutgoingContextError(
+      404,
+      "NOT_FOUND",
+      "Forwarded message was not found",
+    );
+  }
+  return {
+    source,
+    subject: forwardSubject(source.subject),
+  };
+}
+
+export async function resolveReplyContext(input: {
+  env: Env;
+  mailboxId: string;
+  ownAddress: string;
+  sourceEmailId: string;
+  mode: ReplyActionMode;
+  cc?: string[];
+  bcc: string[];
+}): Promise<{
+  source: Email;
+  recipients: RecipientFields;
+  subject: string;
+  detached: boolean;
+  includeRelatedContext: boolean;
+}> {
+  const stub = mailboxStub(input.env, input.mailboxId);
+  const source = await stub.getEmail(input.sourceEmailId);
+  if (!source) {
+    throw new OutgoingContextError(
+      404,
+      "NOT_FOUND",
+      "Reply source was not found",
+    );
+  }
+  if (!canReplyFrom(source)) {
+    throw new OutgoingContextError(
+      409,
+      "NOT_READY",
+      "Wait until the parent message has a confirmed Message-ID",
+    );
+  }
+
+  const plan = buildReplyPlan(input.ownAddress, source);
+  const action = plan.actions.find(
+    (candidate) => candidate.mode === input.mode,
+  );
+  if (!action) {
+    throw new OutgoingContextError(
+      400,
+      "BAD_REQUEST",
+      "Reply mode is not available",
+    );
+  }
+  const recipients = dedupeRecipientFields({
+    to: action.to,
+    cc: input.cc ?? action.cc,
+    bcc: input.bcc,
+  });
+  if (recipientCount(recipients) > MAX_MAIL_RECIPIENTS) {
+    throw new OutgoingContextError(
+      400,
+      "BAD_REQUEST",
+      `An email can have at most ${MAX_MAIL_RECIPIENTS} recipients across To, Cc, and Bcc`,
+    );
+  }
+
+  const history = await stub.getConversation(source.conversationId);
+  return {
+    source,
+    recipients,
+    subject: replySubject(source.subject),
+    detached: shouldDetachOutboundReply({
+      ownAddress: input.ownAddress,
+      plan,
+      to: recipients.to,
+      cc: recipients.cc,
+    }),
+    includeRelatedContext: hasNewRecipients({
+      ownAddress: input.ownAddress,
+      history,
+      ...recipients,
+    }),
+  };
+}

package/worker/mail/participants.ts

@@ -0,0 +1,115 @@
+import { normalizeEmail, normalizeMailboxAddress } from "@open-workspace/core/worker/lib/ids.ts";
+import type { MailAddress } from "../mailbox/model";
+
+export type ParticipantSource = {
+  fromJson: MailAddress[];
+  toJson: MailAddress[];
+  ccJson: MailAddress[];
+  bccJson: MailAddress[];
+};
+
+export type ParticipantSuggestion = {
+  address: string;
+  name: string | null;
+};
+
+export function normalizedParticipantSet(
+  values: Iterable<string>,
+  ownAddress: string,
+) {
+  const own = normalizeMailboxAddress(ownAddress);
+  const result = new Set<string>();
+  for (const value of values) {
+    const normalized = normalizeEmail(value);
+    if (
+      normalized
+      && normalizeMailboxAddress(normalized) !== own
+    ) {
+      result.add(normalized);
+    }
+  }
+  return result;
+}
+
+export function uniqueParticipantAddresses(
+  values: Iterable<MailAddress>,
+  ownAddress: string,
+) {
+  return [
+    ...normalizedParticipantSet(
+      Array.from(values, (value) => value.address),
+      ownAddress,
+    ),
+  ];
+}
+
+export function sameParticipantSet(
+  left: ReadonlySet<string>,
+  right: ReadonlySet<string>,
+) {
+  return left.size === right.size
+    && [...left].every((value) => right.has(value));
+}
+
+export function participantLabels(
+  values: Iterable<MailAddress>,
+  ownAddress: string,
+) {
+  const own = normalizeMailboxAddress(ownAddress);
+  const result = new Map<string, string>();
+  for (const participant of values) {
+    const normalized = normalizeEmail(participant.address);
+    if (
+      !normalized
+      || normalizeMailboxAddress(normalized) === own
+      || result.has(normalized)
+    ) continue;
+    result.set(
+      normalized,
+      participant.name?.trim() || participant.address,
+    );
+  }
+  return [...result.values()];
+}
+
+export function suggestParticipants(
+  messages: Iterable<ParticipantSource>,
+  ownAddress: string,
+  query: string,
+  limit: number,
+  /** Blocked or reported correspondents are never suggested. */
+  exclude: (address: string) => boolean = () => false,
+): ParticipantSuggestion[] {
+  const own = normalizeMailboxAddress(ownAddress);
+  const needle = query.trim().toLocaleLowerCase("en-US");
+  const result = new Map<string, ParticipantSuggestion>();
+
+  for (const message of messages) {
+    for (const participant of [
+      ...message.fromJson,
+      ...message.toJson,
+      ...message.ccJson,
+      ...message.bccJson,
+    ]) {
+      const address = normalizeEmail(participant.address);
+      if (
+        !address
+        || normalizeMailboxAddress(address) === own
+        || result.has(address)
+        || exclude(address.toLocaleLowerCase("en-US"))
+      ) continue;
+      const name = participant.name?.trim() || null;
+      if (
+        needle
+        && !address.toLocaleLowerCase("en-US").includes(needle)
+        && !name?.toLocaleLowerCase("en-US").includes(needle)
+      ) {
+        continue;
+      }
+      result.set(address, { address, name });
+      if (result.size >= limit) return [...result.values()];
+    }
+  }
+
+  return [...result.values()];
+}